From 18d760def656e9585eeb8fc7fb5b3184de90b9cc Mon Sep 17 00:00:00 2001 From: Erheng Lu Date: Mon, 20 Apr 2020 10:51:49 +0800 Subject: [PATCH 01/52] increase ws buffer size --- .../com/binance/dex/api/client/websocket/WebsocketLauncher.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/main/java/com/binance/dex/api/client/websocket/WebsocketLauncher.java b/src/main/java/com/binance/dex/api/client/websocket/WebsocketLauncher.java index 05134d4..0a638d2 100644 --- a/src/main/java/com/binance/dex/api/client/websocket/WebsocketLauncher.java +++ b/src/main/java/com/binance/dex/api/client/websocket/WebsocketLauncher.java @@ -9,6 +9,8 @@ public class WebsocketLauncher { public static boolean startUp(BinanceDexClientEndpoint endpoint){ try { WebSocketContainer container = ContainerProvider.getWebSocketContainer(); + container.setDefaultMaxBinaryMessageBufferSize(128000000); + container.setDefaultMaxTextMessageBufferSize(128000000); container.connectToServer(endpoint,new URI(endpoint.getUrl())); return true; } catch (Exception e) { From 3c1a3d62ac5ca6e595c0b4a7bc869476644a8d96 Mon Sep 17 00:00:00 2001 From: FitzLu Date: Sat, 18 Apr 2020 12:19:56 +0800 Subject: [PATCH 02/52] add sidechain staking --- .../api/client/BinanceDexApiNodeClient.java | 54 +++ .../dex/api/client/BinanceDexNodeApi.java | 6 + .../client/domain/sidechain/Commission.java | 67 +++ .../sidechain/CreateSideChainValidator.java | 82 ++++ .../client/domain/sidechain/Description.java | 67 +++ .../sidechain/EditSideChainValidator.java | 60 +++ .../domain/sidechain/SideChainDelegate.java | 59 +++ .../domain/sidechain/SideChainDelegation.java | 69 +++ .../domain/sidechain/SideChainRedelegate.java | 62 +++ .../sidechain/SideChainRedelegation.java | 109 +++++ .../domain/sidechain/SideChainUnBond.java | 52 ++ .../SideChainUnBondingDelegation.java | 83 ++++ .../domain/sidechain/SideChainValidator.java | 206 ++++++++ .../dex/api/client/encoding/ByteUtil.java | 38 ++ .../dex/api/client/encoding/EncodeUtils.java | 7 +- .../dex/api/client/encoding/amino/Amino.java | 431 +++++++++++++++++ .../encoding/amino/AminoCustomSerialized.java | 25 + .../encoding/amino/AminoDecodeException.java | 26 + .../api/client/encoding/amino/AminoField.java | 70 +++ .../client/encoding/amino/AminoHashing.java | 44 ++ .../encoding/amino/AminoSerializable.java | 16 + .../client/encoding/amino/DisambPrefix.java | 65 +++ .../api/client/encoding/amino/WireType.java | 55 +++ .../client/encoding/amino/types/PubKey.java | 10 + .../encoding/amino/types/PubKeyEd25519.java | 28 ++ .../client/encoding/message/MessageType.java | 7 +- .../api/client/encoding/message/Token.java | 9 + .../message/TransactionMessageWithType.java | 43 ++ .../message/TransactionRequestAssembler.java | 127 +++++ .../sidechain/SideChainClassConverter.java | 75 +++ .../sidechain/query/BechValidator.java | 316 ++++++++++++ .../query/QueryTopValidatorParams.java | 34 ++ .../query/SideChainRedelegationMessage.java | 163 +++++++ .../SideChainUnBondingDelegationMessage.java | 69 +++ .../query/SideChainValidatorMessage.java | 298 ++++++++++++ .../CreateSideChainValidatorMessage.java | 162 +++++++ .../EditSideChainValidatorMessage.java | 107 +++++ .../transaction/SideChainDelegateMessage.java | 108 +++++ .../SideChainRedelegateMessage.java | 124 +++++ .../SideChainUndelegateMessage.java | 109 +++++ .../message/sidechain/value/AddressValue.java | 77 +++ .../message/sidechain/value/CoinValue.java | 86 ++++ .../sidechain/value/CommissionMsgValue.java | 89 ++++ .../sidechain/value/CommissionValue.java | 108 +++++ .../encoding/message/sidechain/value/Dec.java | 60 +++ .../sidechain/value/DelegationValue.java | 62 +++ .../sidechain/value/DescriptionValue.java | 118 +++++ .../sidechain/value/RedelegationValue.java | 118 +++++ .../sidechain/value/TimestampValue.java | 66 +++ .../sidechain/value/TokenMessageValue.java | 73 +++ .../sidechain/value/UnBondingValue.java | 90 ++++ .../AccAddressValueToStringSerializer.java | 21 + .../ByteArrayToStringSerializer.java | 21 + .../serializer/DecToStringSerializer.java | 20 + .../serializer/LongToStringSerializer.java | 17 + .../ValAddressValueToStringSerializer.java | 23 + .../impl/BinanceDexApiNodeClientImpl.java | 123 ++++- ...iNodeClientImplSideChainQueryDelegate.java | 449 ++++++++++++++++++ src/main/proto/dex.proto | 1 + src/main/proto/types.proto | 4 + .../dex/api/client/encoding/AminoTest.java | 32 ++ .../examples/SideChainStakingNodeExample.java | 278 +++++++++++ 62 files changed, 5475 insertions(+), 3 deletions(-) create mode 100644 src/main/java/com/binance/dex/api/client/domain/sidechain/Commission.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/sidechain/CreateSideChainValidator.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/sidechain/Description.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/sidechain/EditSideChainValidator.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainDelegate.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainDelegation.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainRedelegate.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainRedelegation.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainUnBond.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainUnBondingDelegation.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainValidator.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/ByteUtil.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/amino/Amino.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/amino/AminoCustomSerialized.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/amino/AminoDecodeException.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/amino/AminoField.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/amino/AminoHashing.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/amino/AminoSerializable.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/amino/DisambPrefix.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/amino/WireType.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/amino/types/PubKey.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/amino/types/PubKeyEd25519.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/TransactionMessageWithType.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/SideChainClassConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/BechValidator.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryTopValidatorParams.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/SideChainRedelegationMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/SideChainUnBondingDelegationMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/SideChainValidatorMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/CreateSideChainValidatorMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/EditSideChainValidatorMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainDelegateMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainRedelegateMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainUndelegateMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/AddressValue.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/CoinValue.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/CommissionMsgValue.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/CommissionValue.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/Dec.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/DelegationValue.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/DescriptionValue.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/RedelegationValue.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/TimestampValue.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/TokenMessageValue.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/UnBondingValue.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/serializer/AccAddressValueToStringSerializer.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/serializer/ByteArrayToStringSerializer.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/serializer/DecToStringSerializer.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/serializer/LongToStringSerializer.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/serializer/ValAddressValueToStringSerializer.java create mode 100644 src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImplSideChainQueryDelegate.java create mode 100644 src/test/java/com/binance/dex/api/client/encoding/AminoTest.java create mode 100644 src/test/java/com/binance/dex/api/client/examples/SideChainStakingNodeExample.java diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java b/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java index 398b782..57a0d17 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java @@ -7,6 +7,7 @@ import com.binance.dex.api.client.domain.request.OpenOrdersRequest; import com.binance.dex.api.client.domain.request.TradesRequest; import com.binance.dex.api.client.domain.request.TransactionsRequest; +import com.binance.dex.api.client.domain.sidechain.*; import java.io.IOException; import java.security.NoSuchAlgorithmException; @@ -157,4 +158,57 @@ default List freeze(TokenFreeze freeze, Wallet wallet, Tran default List unfreeze(TokenUnfreeze unfreeze, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { throw new UnsupportedOperationException(); } + + default List createSideChainValidator(CreateSideChainValidator createSideChainValidator, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + throw new UnsupportedOperationException(); + } + + default List editSideChainValidator(EditSideChainValidator editSideChainValidator, Wallet wallet, TransactionOption option, boolean synv) throws IOException, NoSuchAlgorithmException { + throw new UnsupportedOperationException(); + } + + default List sideChainDelegate(SideChainDelegate sideChainDelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + throw new UnsupportedOperationException(); + } + + default List sideChainRedelagate(SideChainRedelegate sideChainRedelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + throw new UnsupportedOperationException(); + } + + default List sideChainUnbond(SideChainUnBond sideChainUndelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + throw new UnsupportedOperationException(); + } + + default SideChainValidator getSideChainValidator(String sideChainId, byte[] validatorAddress) throws IOException { + throw new UnsupportedOperationException(); + } + + default List getSideChainTopValidators(String sideChainId, int top) throws IOException { + throw new UnsupportedOperationException(); + } + + default SideChainDelegation getSideChainDelegation(String sideChainId, byte[] delegatorAddress, byte[] validatorAddress) throws IOException { + throw new UnsupportedOperationException(); + } + + default List getSideChainDelegations(String sideChainId, byte[] delegatorAddress) throws IOException { + throw new UnsupportedOperationException(); + } + + default SideChainRedelegation getSideChainRedelegation(String sideChainId, byte[] delegatorAddress, byte[] srcValidatorAddress, byte[] dstValidatorAddress) throws IOException { + throw new UnsupportedOperationException(); + } + + default List getSideChainRedelegations(String sideChainId, byte[] delegatorAddress) throws IOException { + throw new UnsupportedOperationException(); + } + + default SideChainUnBondingDelegation getSideChainUnBondingDelegation(String sideChainId, byte[] delegatorAddress, byte[] validatorAddress) throws IOException { + throw new UnsupportedOperationException(); + } + + default List getSideChainUnBondingDelegations(String sideChainId, byte[] delegatorAddress) throws IOException { + throw new UnsupportedOperationException(); + } + } diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexNodeApi.java b/src/main/java/com/binance/dex/api/client/BinanceDexNodeApi.java index 7d5bc71..edab597 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexNodeApi.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexNodeApi.java @@ -50,4 +50,10 @@ public interface BinanceDexNodeApi { @GET("/block_by_hash") Call> getBlock(@Query("hash") String hash); + @GET("/abci_query?height=0&prove=false") + Call> abciQuery(@Query("path") String path, @Query("data") String data); + + @GET("/abci_query") + Call> abciQueryWithOptions(@Query("path") String path, @Query("data") String data, @Query("height") long height, @Query("prove") boolean prove); + } diff --git a/src/main/java/com/binance/dex/api/client/domain/sidechain/Commission.java b/src/main/java/com/binance/dex/api/client/domain/sidechain/Commission.java new file mode 100644 index 0000000..629aa6e --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/sidechain/Commission.java @@ -0,0 +1,67 @@ +package com.binance.dex.api.client.domain.sidechain; + +/** + * @author Fitz.Lu + **/ +public class Commission { + + private long rate; + + private long maxRate; + + private long maxChangeRate; + + private long updateTimeInMs; + + public long getRate() { + return rate; + } + + public void setRate(long rate) { + this.rate = rate; + } + + public long getMaxRate() { + return maxRate; + } + + public void setMaxRate(long maxRate) { + this.maxRate = maxRate; + } + + public long getMaxChangeRate() { + return maxChangeRate; + } + + public void setMaxChangeRate(long maxChangeRate) { + this.maxChangeRate = maxChangeRate; + } + + public long getUpdateTimeInMs() { + return updateTimeInMs; + } + + public void setUpdateTimeInMs(long updateTimeInMs) { + this.updateTimeInMs = updateTimeInMs; + } + + public Commission() { + } + + public Commission(long rate, long maxRate, long maxChangeRate, long updateTimeInMs) { + this.rate = rate; + this.maxRate = maxRate; + this.maxChangeRate = maxChangeRate; + this.updateTimeInMs = updateTimeInMs; + } + + @Override + public String toString() { + return "Commission{" + + "rate=" + rate + + ", maxRate=" + maxRate + + ", maxChangeRate=" + maxChangeRate + + ", updateTimeInMs=" + updateTimeInMs + + '}'; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/sidechain/CreateSideChainValidator.java b/src/main/java/com/binance/dex/api/client/domain/sidechain/CreateSideChainValidator.java new file mode 100644 index 0000000..33c717a --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/sidechain/CreateSideChainValidator.java @@ -0,0 +1,82 @@ +package com.binance.dex.api.client.domain.sidechain; + +import com.binance.dex.api.client.encoding.message.Token; + +/** + * @author Fitz.Lu + **/ +public class CreateSideChainValidator { + + private Description description; + + private Commission commission; + + private String delegatorAddr; + + private Token delegation; + + private String sideChainId; + + private String sideConsAddr; + + private String sideFeeAddr; + + public CreateSideChainValidator() { + } + + public Description getDescription() { + return description; + } + + public void setDescription(Description description) { + this.description = description; + } + + public Commission getCommission() { + return commission; + } + + public void setCommission(Commission commission) { + this.commission = commission; + } + + public String getDelegatorAddr() { + return delegatorAddr; + } + + public void setDelegatorAddr(String delegatorAddr) { + this.delegatorAddr = delegatorAddr; + } + + public Token getDelegation() { + return delegation; + } + + public void setDelegation(Token delegation) { + this.delegation = delegation; + } + + public String getSideChainId() { + return sideChainId; + } + + public void setSideChainId(String sideChainId) { + this.sideChainId = sideChainId; + } + + public String getSideConsAddr() { + return sideConsAddr; + } + + public void setSideConsAddr(String sideConsAddr) { + this.sideConsAddr = sideConsAddr; + } + + public String getSideFeeAddr() { + return sideFeeAddr; + } + + public void setSideFeeAddr(String sideFeeAddr) { + this.sideFeeAddr = sideFeeAddr; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/sidechain/Description.java b/src/main/java/com/binance/dex/api/client/domain/sidechain/Description.java new file mode 100644 index 0000000..0bab14e --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/sidechain/Description.java @@ -0,0 +1,67 @@ +package com.binance.dex.api.client.domain.sidechain; + +/** + * @author Fitz.Lu + **/ +public class Description { + + private String moniker = ""; + + private String identity = ""; + + private String website = ""; + + private String details = ""; + + public Description() { + } + + public Description(String moniker, String identity, String website, String details) { + this.moniker = moniker; + this.identity = identity; + this.website = website; + this.details = details; + } + + public String getMoniker() { + return moniker; + } + + public void setMoniker(String moniker) { + this.moniker = moniker; + } + + public String getIdentity() { + return identity; + } + + public void setIdentity(String identity) { + this.identity = identity; + } + + public String getWebsite() { + return website; + } + + public void setWebsite(String website) { + this.website = website; + } + + public String getDetails() { + return details; + } + + public void setDetails(String details) { + this.details = details; + } + + @Override + public String toString() { + return "Description{" + + "moniker='" + moniker + '\'' + + ", identity='" + identity + '\'' + + ", website='" + website + '\'' + + ", details='" + details + '\'' + + '}'; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/sidechain/EditSideChainValidator.java b/src/main/java/com/binance/dex/api/client/domain/sidechain/EditSideChainValidator.java new file mode 100644 index 0000000..88361be --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/sidechain/EditSideChainValidator.java @@ -0,0 +1,60 @@ +package com.binance.dex.api.client.domain.sidechain; + +/** + * @author Fitz.Lu + **/ +public class EditSideChainValidator { + + private Description description; + + private long commissionRate; + + private String sideChainId; + + private String sideConsAddr; + + private String sideFeeAddr; + + public EditSideChainValidator() { + } + + public Description getDescription() { + return description; + } + + public void setDescription(Description description) { + this.description = description; + } + + public long getCommissionRate() { + return commissionRate; + } + + public void setCommissionRate(long commissionRate) { + this.commissionRate = commissionRate; + } + + public String getSideChainId() { + return sideChainId; + } + + public void setSideChainId(String sideChainId) { + this.sideChainId = sideChainId; + } + + public String getSideConsAddr() { + return sideConsAddr; + } + + public void setSideConsAddr(String sideConsAddr) { + this.sideConsAddr = sideConsAddr; + } + + public String getSideFeeAddr() { + return sideFeeAddr; + } + + public void setSideFeeAddr(String sideFeeAddr) { + this.sideFeeAddr = sideFeeAddr; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainDelegate.java b/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainDelegate.java new file mode 100644 index 0000000..62335c9 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainDelegate.java @@ -0,0 +1,59 @@ +package com.binance.dex.api.client.domain.sidechain; + +import com.binance.dex.api.client.encoding.message.Token; + +/** + * @author Fitz.Lu + **/ +public class SideChainDelegate { + + private String delegatorAddress; + + private String validatorAddress; + + private Token delegation; + + private String sideChainId = ""; + + public SideChainDelegate() { + } + + public SideChainDelegate(String delegatorAddress, String validatorAddress, Token delegation, String sideChainId) { + this.delegatorAddress = delegatorAddress; + this.validatorAddress = validatorAddress; + this.delegation = delegation; + this.sideChainId = sideChainId; + } + + public String getDelegatorAddress() { + return delegatorAddress; + } + + public void setDelegatorAddress(String delegatorAddress) { + this.delegatorAddress = delegatorAddress; + } + + public String getValidatorAddress() { + return validatorAddress; + } + + public void setValidatorAddress(String validatorAddress) { + this.validatorAddress = validatorAddress; + } + + public Token getDelegation() { + return delegation; + } + + public void setDelegation(Token delegation) { + this.delegation = delegation; + } + + public String getSideChainId() { + return sideChainId; + } + + public void setSideChainId(String sideChainId) { + this.sideChainId = sideChainId; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainDelegation.java b/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainDelegation.java new file mode 100644 index 0000000..411777e --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainDelegation.java @@ -0,0 +1,69 @@ +package com.binance.dex.api.client.domain.sidechain; + +import java.util.Arrays; + +/** + * @author Fitz.Lu + **/ +public class SideChainDelegation { + + private byte[] delegatorAddress; + + private byte[] validatorAddress; + + private long shares; + + private long height; + + public SideChainDelegation() { + } + + public SideChainDelegation(byte[] delegatorAddress, byte[] validatorAddress, long shares, long height) { + this.delegatorAddress = delegatorAddress; + this.validatorAddress = validatorAddress; + this.shares = shares; + this.height = height; + } + + public byte[] getDelegatorAddress() { + return delegatorAddress; + } + + public void setDelegatorAddress(byte[] delegatorAddress) { + this.delegatorAddress = delegatorAddress; + } + + public byte[] getValidatorAddress() { + return validatorAddress; + } + + public void setValidatorAddress(byte[] validatorAddress) { + this.validatorAddress = validatorAddress; + } + + public long getShares() { + return shares; + } + + public void setShares(long shares) { + this.shares = shares; + } + + public long getHeight() { + return height; + } + + public void setHeight(long height) { + this.height = height; + } + + @Override + public String toString() { + return "SideChainDelegation{" + + "delegatorAddress=" + Arrays.toString(delegatorAddress) + + ", validatorAddress=" + Arrays.toString(validatorAddress) + + ", shares=" + shares + + ", height=" + height + + '}'; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainRedelegate.java b/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainRedelegate.java new file mode 100644 index 0000000..1aedeeb --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainRedelegate.java @@ -0,0 +1,62 @@ +package com.binance.dex.api.client.domain.sidechain; + +import com.binance.dex.api.client.encoding.message.Token; + +/** + * @author Fitz.Lu + **/ +public class SideChainRedelegate { + + private String delegatorAddress; + + private String srcValidatorAddress; + + private String dstValidatorAddress; + + private Token amount; + + private String sideChainId; + + public SideChainRedelegate() { + } + + public String getDelegatorAddress() { + return delegatorAddress; + } + + public void setDelegatorAddress(String delegatorAddress) { + this.delegatorAddress = delegatorAddress; + } + + public String getSrcValidatorAddress() { + return srcValidatorAddress; + } + + public void setSrcValidatorAddress(String srcValidatorAddress) { + this.srcValidatorAddress = srcValidatorAddress; + } + + public String getDstValidatorAddress() { + return dstValidatorAddress; + } + + public void setDstValidatorAddress(String dstValidatorAddress) { + this.dstValidatorAddress = dstValidatorAddress; + } + + public Token getAmount() { + return amount; + } + + public void setAmount(Token amount) { + this.amount = amount; + } + + public String getSideChainId() { + return sideChainId; + } + + public void setSideChainId(String sideChainId) { + this.sideChainId = sideChainId; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainRedelegation.java b/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainRedelegation.java new file mode 100644 index 0000000..366cb39 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainRedelegation.java @@ -0,0 +1,109 @@ +package com.binance.dex.api.client.domain.sidechain; + + +import com.binance.dex.api.client.encoding.message.Token; + +/** + * @author Fitz.Lu + **/ +public class SideChainRedelegation { + + //delegator address + private byte[] delegatorAddress; + + //validator redelegation source operator address + private byte[] srcValidatorAddress; + + //validator redelegation destination operator address + private byte[] dstValidatorAddress; + + //height which the redelegation took place + private long createHeight; + + //unix time for redelegation completion + private long minTimeInMs; + + //initial balance when redelegation started + private Token initialBalance; + + //current balance + private Token balance; + + //amount of source shares redelegating + private long srcShares; + + //amount of destination shares redelegating + private long dstShare; + + public byte[] getDelegatorAddress() { + return delegatorAddress; + } + + public void setDelegatorAddress(byte[] delegatorAddress) { + this.delegatorAddress = delegatorAddress; + } + + public byte[] getSrcValidatorAddress() { + return srcValidatorAddress; + } + + public void setSrcValidatorAddress(byte[] srcValidatorAddress) { + this.srcValidatorAddress = srcValidatorAddress; + } + + public byte[] getDstValidatorAddress() { + return dstValidatorAddress; + } + + public void setDstValidatorAddress(byte[] dstValidatorAddress) { + this.dstValidatorAddress = dstValidatorAddress; + } + + public long getCreateHeight() { + return createHeight; + } + + public void setCreateHeight(long createHeight) { + this.createHeight = createHeight; + } + + public long getMinTimeInMs() { + return minTimeInMs; + } + + public void setMinTimeInMs(long minTimeInMs) { + this.minTimeInMs = minTimeInMs; + } + + public Token getInitialBalance() { + return initialBalance; + } + + public void setInitialBalance(Token initialBalance) { + this.initialBalance = initialBalance; + } + + public Token getBalance() { + return balance; + } + + public void setBalance(Token balance) { + this.balance = balance; + } + + public long getSrcShares() { + return srcShares; + } + + public void setSrcShares(long srcShares) { + this.srcShares = srcShares; + } + + public long getDstShare() { + return dstShare; + } + + public void setDstShare(long dstShare) { + this.dstShare = dstShare; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainUnBond.java b/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainUnBond.java new file mode 100644 index 0000000..583bf06 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainUnBond.java @@ -0,0 +1,52 @@ +package com.binance.dex.api.client.domain.sidechain; + +import com.binance.dex.api.client.encoding.message.Token; + +/** + * @author Fitz.Lu + **/ +public class SideChainUnBond { + + private String delegatorAddress; + + private String validatorAddress; + + private Token amount; + + private String sideChainId; + + public SideChainUnBond() { + } + + public String getDelegatorAddress() { + return delegatorAddress; + } + + public void setDelegatorAddress(String delegatorAddress) { + this.delegatorAddress = delegatorAddress; + } + + public String getValidatorAddress() { + return validatorAddress; + } + + public void setValidatorAddress(String validatorAddress) { + this.validatorAddress = validatorAddress; + } + + public Token getAmount() { + return amount; + } + + public void setAmount(Token amount) { + this.amount = amount; + } + + public String getSideChainId() { + return sideChainId; + } + + public void setSideChainId(String sideChainId) { + this.sideChainId = sideChainId; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainUnBondingDelegation.java b/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainUnBondingDelegation.java new file mode 100644 index 0000000..6b85ece --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainUnBondingDelegation.java @@ -0,0 +1,83 @@ +package com.binance.dex.api.client.domain.sidechain; + +import com.binance.dex.api.client.encoding.message.Token; + +import java.util.Arrays; + +/** + * @author Fitz.Lu + **/ +public class SideChainUnBondingDelegation { + + private byte[] delegatorAddress; + + private byte[] validatorAddress; + + private long createHeight; + + private long minTimeInMs; + + private Token initialBalance; + + private Token balance; + + public byte[] getDelegatorAddress() { + return delegatorAddress; + } + + public void setDelegatorAddress(byte[] delegatorAddress) { + this.delegatorAddress = delegatorAddress; + } + + public byte[] getValidatorAddress() { + return validatorAddress; + } + + public void setValidatorAddress(byte[] validatorAddress) { + this.validatorAddress = validatorAddress; + } + + public long getCreateHeight() { + return createHeight; + } + + public void setCreateHeight(long createHeight) { + this.createHeight = createHeight; + } + + public long getMinTimeInMs() { + return minTimeInMs; + } + + public void setMinTimeInMs(long minTimeInMs) { + this.minTimeInMs = minTimeInMs; + } + + public Token getInitialBalance() { + return initialBalance; + } + + public void setInitialBalance(Token initialBalance) { + this.initialBalance = initialBalance; + } + + public Token getBalance() { + return balance; + } + + public void setBalance(Token balance) { + this.balance = balance; + } + + @Override + public String toString() { + return "SideChainUnBondingDelegation{" + + "delegatorAddress=" + Arrays.toString(delegatorAddress) + + ", validatorAddress=" + Arrays.toString(validatorAddress) + + ", createHeight=" + createHeight + + ", minTimeInMs=" + minTimeInMs + + ", initialBalance=" + initialBalance + + ", balance=" + balance + + '}'; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainValidator.java b/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainValidator.java new file mode 100644 index 0000000..f0eef18 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainValidator.java @@ -0,0 +1,206 @@ +package com.binance.dex.api.client.domain.sidechain; + +import java.util.Arrays; + +/** + * @author Fitz.Lu + **/ +public class SideChainValidator { + + private byte[] feeAddr; + + private byte[] operatorAddr; + + private byte[] consPubKey; + + private boolean jailed; + + private int status; + + private long tokens; + + private long delegatorShares; + + private Description description; + + private long bondHeight; + + private int bondIntraTxCounter; + + private long unBondingHeight; + + private long unBondingMinTime; + + private Commission commission; + + private byte[] distributionAddr; + + private String sideChainId; + + private byte[] sideConsAddr; + + private byte[] sideFeeAddr; + + public SideChainValidator() { + } + + public byte[] getFeeAddr() { + return feeAddr; + } + + public void setFeeAddr(byte[] feeAddr) { + this.feeAddr = feeAddr; + } + + public byte[] getOperatorAddr() { + return operatorAddr; + } + + public void setOperatorAddr(byte[] operatorAddr) { + this.operatorAddr = operatorAddr; + } + + public byte[] getConsPubKey() { + return consPubKey; + } + + public void setConsPubKey(byte[] consPubKey) { + this.consPubKey = consPubKey; + } + + public boolean isJailed() { + return jailed; + } + + public void setJailed(boolean jailed) { + this.jailed = jailed; + } + + public int getStatus() { + return status; + } + + public void setStatus(int status) { + this.status = status; + } + + public long getTokens() { + return tokens; + } + + public void setTokens(long tokens) { + this.tokens = tokens; + } + + public long getDelegatorShares() { + return delegatorShares; + } + + public void setDelegatorShares(long delegatorShares) { + this.delegatorShares = delegatorShares; + } + + public Description getDescription() { + return description; + } + + public void setDescription(Description description) { + this.description = description; + } + + public long getBondHeight() { + return bondHeight; + } + + public void setBondHeight(long bondHeight) { + this.bondHeight = bondHeight; + } + + public int getBondIntraTxCounter() { + return bondIntraTxCounter; + } + + public void setBondIntraTxCounter(int bondIntraTxCounter) { + this.bondIntraTxCounter = bondIntraTxCounter; + } + + public long getUnBondingHeight() { + return unBondingHeight; + } + + public void setUnBondingHeight(long unBondingHeight) { + this.unBondingHeight = unBondingHeight; + } + + public long getUnBondingMinTime() { + return unBondingMinTime; + } + + public void setUnBondingMinTime(long unBondingMinTime) { + this.unBondingMinTime = unBondingMinTime; + } + + public Commission getCommission() { + return commission; + } + + public void setCommission(Commission commission) { + this.commission = commission; + } + + public byte[] getDistributionAddr() { + return distributionAddr; + } + + public void setDistributionAddr(byte[] distributionAddr) { + distributionAddr = distributionAddr; + } + + public String getSideChainId() { + return sideChainId; + } + + public void setSideChainId(String sideChainId) { + this.sideChainId = sideChainId; + } + + public byte[] getSideConsAddr() { + return sideConsAddr; + } + + public void setSideConsAddr(byte[] sideConsAddr) { + this.sideConsAddr = sideConsAddr; + } + + public byte[] getSideFeeAddr() { + return sideFeeAddr; + } + + public void setSideFeeAddr(byte[] sideFeeAddr) { + this.sideFeeAddr = sideFeeAddr; + } + + @Override + public String toString() { + return "SideChainValidator{" + + "feeAddr=" + Arrays.toString(feeAddr) + '\n' + + ", operatorAddr=" + Arrays.toString(operatorAddr) + '\n' + + ", consPubKey='" + consPubKey + '\'' + '\n' + + ", jailed=" + jailed + '\n' + + ", status=" + status + '\n' + + ", tokens=" + tokens + '\n' + + ", delegatorShares=" + delegatorShares + '\n' + + ", description=" + description + '\n' + + ", bondHeight=" + bondHeight + '\n' + + ", bondIntraTxCounter=" + bondIntraTxCounter + '\n' + + ", unBondingHeight=" + unBondingHeight + '\n' + + ", unBondingMinTime=" + unBondingMinTime + '\n' + + ", commission=" + commission + '\n' + + ", distributionAddr=" + Arrays.toString(distributionAddr) + '\n' + + ", sideChainId='" + sideChainId + '\'' + '\n' + + ", sideConsAddr=" + Arrays.toString(sideConsAddr) + '\n' + + ", sideFeeAddr=" + Arrays.toString(sideFeeAddr) + '\n' + + '}'; + } + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/ByteUtil.java b/src/main/java/com/binance/dex/api/client/encoding/ByteUtil.java new file mode 100644 index 0000000..4fe70f3 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/ByteUtil.java @@ -0,0 +1,38 @@ +package com.binance.dex.api.client.encoding; + +/** + * @author Fitz.Lu + **/ +//TODO add safe check +public class ByteUtil { + + public static boolean isEmpty(byte[] bytes){ + return bytes == null || bytes.length == 0; + } + + public static byte[] read(byte[] bytes, int length){ + byte[] newBytes = new byte[length]; + System.arraycopy(bytes, 0, newBytes, 0, length); + return newBytes; + } + + public static byte[] cut(byte[] bytes, int length){ + byte[] newBytes = new byte[bytes.length - length]; + System.arraycopy(bytes, length, newBytes, 0, newBytes.length); + return newBytes; + } + + public static byte[] pick(byte[] bytes, int start, int length){ + byte[] newBytes = new byte[length]; + System.arraycopy(bytes, start, newBytes, 0, length); + return newBytes; + } + + public static byte[] appendBytesArray(byte[] first, byte[] second){ + byte[] newArray = new byte[first.length + second.length]; + System.arraycopy(first, 0, newArray, 0, first.length); + System.arraycopy(second, 0, newArray, first.length, second.length); + return newArray; + } + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/EncodeUtils.java b/src/main/java/com/binance/dex/api/client/encoding/EncodeUtils.java index 2d0c6c7..50faaee 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/EncodeUtils.java +++ b/src/main/java/com/binance/dex/api/client/encoding/EncodeUtils.java @@ -2,6 +2,7 @@ import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; +import com.google.common.base.Charsets; import com.google.protobuf.CodedOutputStream; import org.bouncycastle.util.encoders.Hex; @@ -34,7 +35,7 @@ public static T toObjectFromJsonString(String jsonString,Class tClass) th } public static byte[] toJsonEncodeBytes(Object object) throws JsonProcessingException { - return toJsonStringSortKeys(object).getBytes(Charset.forName("UTF-8")); + return toJsonStringSortKeys(object).getBytes(Charsets.UTF_8); } public static byte[] aminoWrap(byte[] raw, byte[] typePrefix, boolean isPrefixLength) throws IOException { @@ -68,4 +69,8 @@ public static byte[] long2Bytes(long x){ return buffer.array(); } + public static ObjectMapper getObjectMapper() { + return OBJECT_MAPPER; + } + } diff --git a/src/main/java/com/binance/dex/api/client/encoding/amino/Amino.java b/src/main/java/com/binance/dex/api/client/encoding/amino/Amino.java new file mode 100644 index 0000000..024258b --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/amino/Amino.java @@ -0,0 +1,431 @@ +package com.binance.dex.api.client.encoding.amino; + +import com.binance.dex.api.client.encoding.ByteUtil; +import com.google.protobuf.CodedInputStream; +import com.google.protobuf.CodedOutputStream; +import org.bouncycastle.util.encoders.Hex; + +import java.io.IOException; +import java.security.NoSuchAlgorithmException; +import java.util.Arrays; + +/** + * @author Fitz.Lu + **/ +public class Amino { + + private static final int disambiguationByteSize = 3; + + private static final int prefixByteSize = 4; + + /** + * > Amino Disamb and Prefix + * > hash := sha256("com.tendermint.consensus/MyConcreteName") + * > hex.EncodeBytes(hash) // 0x{00 00 A8 FC 54 00 00 00 BB 9C 83 DD ...} (example) + * > rest = dropLeadingZeroBytes(hash) // 0x{A8 FC 54 00 00 00 BB 9C 83 DD ...} + * > disamb = rest[0:3] + * > rest = dropLeadingZeroBytes(rest[3:]) + * > prefix = rest[0:4] + * > <0xA8 0xFC 0x54> [0xBB 0x9C 9x83 9xDD] // and [Prefix Bytes] + **/ + + /** + * Return disambiguation bytes from given name, the first three non-zero bytes + * + * @param name the name + */ + public byte[] nameToDisamb(String name){ + return nameToDisambPrefix(name).getDisamb(); + } + + /** + * Return prefix bytes from given name, the first four non-zero bytes + * + * @param name the name + */ + public byte[] nameToPrefix(String name) { + return nameToDisambPrefix(name).getPrefix(); + } + + public String nameToPrefixString(String name) { + return Hex.toHexString(nameToDisambPrefix(name).getPrefix()); + } + + /** + * Return disambiguation and prefix bytes pair from given name + * + * @param name the name + * @see DisambPrefix + */ + public DisambPrefix nameToDisambPrefix(String name) { + DisambPrefix disambPrefix = new DisambPrefix(); + byte[] nameHash = new byte[0]; + try { + nameHash = dropLeadingZero(AminoHashing.sha256(name)); + } catch (NoSuchAlgorithmException e) { + e.printStackTrace(); + } + disambPrefix.setDisamb(Arrays.copyOfRange(nameHash, 0, disambiguationByteSize)); + + byte[] rest = Arrays.copyOfRange(nameHash, disambiguationByteSize, nameHash.length); + disambPrefix.setPrefix(Arrays.copyOfRange(dropLeadingZero(rest), 0, prefixByteSize)); + + byte[] dp = new byte[disambiguationByteSize + prefixByteSize]; + System.arraycopy(disambPrefix.getDisamb(), 0, dp, 0, disambiguationByteSize); + System.arraycopy(disambPrefix.getPrefix(), 0, dp, disambiguationByteSize, prefixByteSize); + + disambPrefix.setDisambPrefix(dp); + + return disambPrefix; + } + + private byte[] dropLeadingZero(byte[] byteArray) { + int offset = 0; + for (byte oneByte : byteArray) { + if (oneByte != 0) { + break; + } + offset++; + } + return Arrays.copyOfRange(byteArray, offset, byteArray.length); + + } + + /** + * > Amino encode + * */ + public byte[] encode(AminoSerializable message, byte[] typePrefix, boolean lengthPrefix) throws IOException { + boolean writeTypePrefix = false; + boolean writeLengthPrefix = false; + int length = computeSerializedSize(message); + + if (typePrefix != null && typePrefix.length > 0){ + length += typePrefix.length; + writeTypePrefix = true; + } + + int bufSize = length; + + if (lengthPrefix){ + bufSize += computeLengthByteSize(length); + writeLengthPrefix = true; + } + byte[] buf = new byte[bufSize]; + CodedOutputStream outputStream = CodedOutputStream.newInstance(buf); + + if (writeLengthPrefix){ + encodeLengthByte(length, outputStream); + } + + if (writeTypePrefix) { + outputStream.writeRawBytes(typePrefix); + } + + encodeAminoMessageBare(message, outputStream); + + outputStream.flush(); + + return buf; + } + + private void encodeAminoMessageBare(AminoSerializable message, CodedOutputStream outputStream) throws IOException { + int index = 0; + for (AminoField field : message.IterateFields()) { + index ++; + + if (field.isSkipWhenEncode() || field.getT() == null){ + continue; + } + + if (field.getT() instanceof AminoCustomSerialized){ + encodeAminoSerialized(index, (AminoCustomSerialized) field.getT(), outputStream); + continue; + } + + if (field.getT() instanceof AminoSerializable) { + outputStream.writeTag(index, WireType.LENGTH_DELIMITED); + int length = computeSerializedSize(((AminoSerializable) field.getT())); + encodeLengthByte(length, outputStream); + encodeAminoMessageBare(((AminoSerializable) field.getT()), outputStream); + continue; + } + + if (field.getT() instanceof String){ + encodeString(index, (String) field.getT(), outputStream); + continue; + } + + if (field.getT() instanceof byte[]){ + encodeByteArray(index, ((byte[]) field.getT()), outputStream); + continue; + } + + if (field.getT() instanceof Long){ + encodeInt64(index, ((Long) field.getT()), outputStream); + } + } + } + + public void decodeBare(byte[] data, AminoSerializable message) throws IOException, AminoDecodeException { + CodedInputStream input = CodedInputStream.newInstance(data); + try { + decode(input, message); + } catch (IllegalAccessException | InstantiationException e) { + throw new AminoDecodeException(e); + } + } + + public void decodeWithLengthPrefix(byte[] data, AminoSerializable message) throws IOException, AminoDecodeException { + CodedInputStream input = CodedInputStream.newInstance(data); + if (input.isAtEnd()){ + return; + } + + int length = input.readRawVarint32(); + if (length == 0){ + return; + } + + try { + decode(input, message); + } catch (IllegalAccessException | InstantiationException e) { + throw new AminoDecodeException(e); + } + } + + public static byte[] getByteArrayAfterTypePrefix(byte[] data) throws IllegalStateException { + byte[] typePrefix = ByteUtil.read(data, prefixByteSize); + //todo match type prefix from registered map + int length = Byte.toUnsignedInt(data[4]); + if (data.length - prefixByteSize - 1 != length){ + throw new IllegalStateException("Invalid Amino buffer"); + } + return ByteUtil.pick(data, prefixByteSize + 1, length); + } + + private void decode(CodedInputStream input, AminoSerializable message) throws IOException, IllegalAccessException, InstantiationException { + int index = 0; + int tag = 0; + boolean pendTag = false; + for (AminoField iterateField : message.IterateFields()) { + index ++; + + if (!pendTag) { + tag = input.readTag(); + } + + int currentFieldTag = computeTag(index, iterateField.getClazz()); + + if (currentFieldTag != tag){ + pendTag = true; + continue; + }else{ + pendTag = false; + } + + if (AminoCustomSerialized.class.isAssignableFrom(iterateField.getClazz())){ + Object obj; + if (iterateField.getT() != null){ + ((AminoCustomSerialized) iterateField.getT()).decode(input); + obj = iterateField.getT(); + }else{ + Object serializedObj = iterateField.getClazz().newInstance(); + ((AminoCustomSerialized) serializedObj).decode(input); + obj = serializedObj; + } + message.setValueByFieldIndex(index, obj); + continue; + } + + if (AminoSerializable.class.isAssignableFrom(iterateField.getClazz())){ + int length = input.readRawVarint32(); + if (length == 0){ + continue; + } + Object msg; + if (iterateField.getT() != null){ + msg = iterateField.getT(); + }else{ + msg = iterateField.getClazz().newInstance(); + } + + final int oldLimit = input.pushLimit(length); + decode(input, ((AminoSerializable) msg)); + //update lastTag in input stream + int emptyTag = input.readTag(); + //check is at the end + if (emptyTag != 0){ + throw new AminoDecodeException("Embedded message tag did not match expected tag"); + } + //double check + input.checkLastTagWas(0); + input.popLimit(oldLimit); + + message.setValueByFieldIndex(index, msg); + continue; + } + + if (iterateField.getClazz().isAssignableFrom(Boolean.class)){ + message.setValueByFieldIndex(index, input.readBool()); + continue; + } + + if (iterateField.getClazz().isAssignableFrom(Integer.class)){ + message.setValueByFieldIndex(index, input.readInt32()); + continue; + } + + if (iterateField.getClazz().isAssignableFrom(Long.class)){ + message.setValueByFieldIndex(index, input.readInt64()); + continue; + } + + if (iterateField.getClazz().isAssignableFrom(String.class)){ + message.setValueByFieldIndex(index, input.readStringRequireUtf8()); + continue; + } + + if (iterateField.getClazz().isAssignableFrom(byte[].class)){ + byte[] value = input.readByteArray(); + message.setValueByFieldIndex(index, value); + continue; + } + } + } + + private void encodeAminoSerialized(int fieldIndex, AminoCustomSerialized aminoCustomSerialized, CodedOutputStream outputStream) throws IOException { + if (!aminoCustomSerialized.isDefaultOrEmpty()) { + outputStream.writeTag(fieldIndex, aminoCustomSerialized.getWireType()); + aminoCustomSerialized.encode(outputStream); + } + } + + private void encodeString(int fieldIndex, String value, CodedOutputStream outputStream) throws IOException { + outputStream.writeTag(fieldIndex, WireType.LENGTH_DELIMITED); + outputStream.writeStringNoTag(value); + } + + private void encodeByteArray(int fieldIndex, byte[] array, CodedOutputStream outputStream) throws IOException { + outputStream.writeTag(fieldIndex, WireType.LENGTH_DELIMITED); + outputStream.writeByteArrayNoTag(array); + } + + private void encodeInt64(int fieldIndex, long value, CodedOutputStream outputStream) throws IOException { + outputStream.writeTag(fieldIndex, WireType.VARINT); + outputStream.writeInt64NoTag(value); + } + + private void encodeUInt32Bare(int value, CodedOutputStream codedOutputStream) throws IOException { + codedOutputStream.writeUInt32NoTag(value); + } + + private void encodeLengthByte(int length, CodedOutputStream codedOutputStream) throws IOException { + codedOutputStream.writeUInt32NoTag(length); + } + + public int computeSerializedSize(AminoSerializable message){ + int size = 0; + int index = 0; + for (AminoField iterateField : message.IterateFields()) { + index ++; + + if (iterateField.isSkipWhenEncode() || iterateField.getT() == null){ + continue; + } + + if (iterateField.getT() instanceof AminoCustomSerialized){ + size += computeTagSize(index, ((AminoCustomSerialized) iterateField.getT()).getWireType()); + size += ((AminoCustomSerialized) iterateField.getT()).getSerializedSize(); + continue; + } + + if (iterateField.getT() instanceof AminoSerializable){ + size += computeTagSize(index, WireType.LENGTH_DELIMITED); + int embeddedSize = computeSerializedSize(((AminoSerializable) iterateField.getT())); + size += computeLengthByteSize(embeddedSize); + size += embeddedSize; + continue; + } + + if (iterateField.getT() instanceof String){ + size += computeTagSize(index, WireType.LENGTH_DELIMITED); + size += computeStringSize(((String)iterateField.getT())); + continue; + } + + if (iterateField.getT() instanceof byte[]) { + size += computeTagSize(index, WireType.LENGTH_DELIMITED); + size += computeByteArraySize(((byte[]) iterateField.getT())); + continue; + } + + if (iterateField.getT() instanceof Long){ + size += computeTagSize(index, WireType.VARINT); + size += computeInt64Size(((Long) iterateField.getT())); + } + } + + return size; + } + + private int computeTagSize(final int fieldNumber, final int wireType){ + return CodedOutputStream.computeUInt32SizeNoTag(makeTag(fieldNumber, wireType)); + } + + private int computeByteArraySize(final byte[] bytes){ + return CodedOutputStream.computeByteArraySizeNoTag(bytes); + } + + private int computeStringSize(final String str){ + return CodedOutputStream.computeStringSizeNoTag(str); + } + + private int computeInt32Size(final int value){ + return CodedOutputStream.computeInt32SizeNoTag(value); + } + + private int computeUInt32Size(final int value){ + return CodedOutputStream.computeUInt32SizeNoTag(value); + } + + private int computeLengthByteSize(final int length){ + return CodedOutputStream.computeUInt32SizeNoTag(length); + } + + private int computeInt64Size(final long value){ + return CodedOutputStream.computeInt64SizeNoTag(value); + } + + private int computeUInt64Size(final long value){ + return CodedOutputStream.computeUInt64SizeNoTag(value); + } + + private int computeTag(int fieldIndex, Class clazz){ + if (AminoCustomSerialized.class.isAssignableFrom(clazz) || + AminoSerializable.class.isAssignableFrom(clazz) || + clazz.isAssignableFrom(byte[].class) || + clazz.isAssignableFrom(String.class)){ + return makeTag(fieldIndex, WireType.LENGTH_DELIMITED); + } + + if (clazz.isAssignableFrom(Long.class) || + clazz.isAssignableFrom(Integer.class) || + clazz.isAssignableFrom(Boolean.class)) { + return makeTag(fieldIndex, WireType.VARINT); + } + + throw new IllegalArgumentException("Unsupported class " + clazz.getCanonicalName()); + } + + private int makeTag(final int fieldNumber, final int wireType){ + return (fieldNumber << 3) | wireType; + } + + private byte[] appendBytesArray(byte[] first, byte[] second){ + byte[] newArray = new byte[first.length + second.length]; + System.arraycopy(first, 0, newArray, 0, first.length); + System.arraycopy(second, 0, newArray, first.length, second.length); + return newArray; + } + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/amino/AminoCustomSerialized.java b/src/main/java/com/binance/dex/api/client/encoding/amino/AminoCustomSerialized.java new file mode 100644 index 0000000..ac949fd --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/amino/AminoCustomSerialized.java @@ -0,0 +1,25 @@ +package com.binance.dex.api.client.encoding.amino; + +import com.google.protobuf.CodedInputStream; +import com.google.protobuf.CodedOutputStream; + +import java.io.IOException; + +/** + * @author Fitz.Lu + **/ +public interface AminoCustomSerialized { + + AminoCustomSerialized newAminoSerInstance(); + + boolean isDefaultOrEmpty(); + + void encode(CodedOutputStream outputStream) throws IOException; + + int getWireType(); + + void decode(CodedInputStream inputStream) throws IOException; + + int getSerializedSize(); + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/amino/AminoDecodeException.java b/src/main/java/com/binance/dex/api/client/encoding/amino/AminoDecodeException.java new file mode 100644 index 0000000..eec8006 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/amino/AminoDecodeException.java @@ -0,0 +1,26 @@ +package com.binance.dex.api.client.encoding.amino; + +/** + * @author Fitz.Lu + **/ +public class AminoDecodeException extends RuntimeException { + + public AminoDecodeException() { + } + + public AminoDecodeException(String message) { + super(message); + } + + public AminoDecodeException(String message, Throwable cause) { + super(message, cause); + } + + public AminoDecodeException(Throwable cause) { + super(cause); + } + + public AminoDecodeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/amino/AminoField.java b/src/main/java/com/binance/dex/api/client/encoding/amino/AminoField.java new file mode 100644 index 0000000..d3c2a44 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/amino/AminoField.java @@ -0,0 +1,70 @@ +package com.binance.dex.api.client.encoding.amino; + +import javax.annotation.Nullable; +import java.util.ArrayList; + +/** + * @author Fitz.Lu + **/ +public class AminoField { + + public static AminoFieldsBuilder newFieldsBuilder(){ + return new AminoFieldsBuilder(); + } + + private Class clazz; + + private T t; + + private boolean skipWhenEncode = false; + + public AminoField(Class clazz, @Nullable T t, boolean skipWhenEncode) { + this.clazz = clazz; + this.t = t; + this.skipWhenEncode = skipWhenEncode; + } + + public Class getClazz() { + return clazz; + } + + public void setClazz(Class clazz) { + this.clazz = clazz; + } + + public T getT() { + return t; + } + + public void setT(T t) { + this.t = t; + } + + public boolean isSkipWhenEncode() { + return skipWhenEncode; + } + + public void setSkipWhenEncode(boolean skipWhenEncode) { + this.skipWhenEncode = skipWhenEncode; + } + + public static class AminoFieldsBuilder { + + private final ArrayList> fields; + + public AminoFieldsBuilder(){ + fields = new ArrayList<>(); + } + + public AminoFieldsBuilder addField(Class clazz, T2 value, boolean skipWhenEncode){ + fields.add(new AminoField<>(clazz, value, skipWhenEncode)); + return this; + } + + public ArrayList> build(){ + return fields; + } + + } + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/amino/AminoHashing.java b/src/main/java/com/binance/dex/api/client/encoding/amino/AminoHashing.java new file mode 100644 index 0000000..9f769cb --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/amino/AminoHashing.java @@ -0,0 +1,44 @@ +package com.binance.dex.api.client.encoding.amino; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; + +/** + * author: Fitz + **/ +class AminoHashing { + + private final static char[] hexArray = "0123456789ABCDEF".toCharArray(); + private final static String SHA256 = "SHA-256"; + + public static byte[] sha256(byte[] arg) throws NoSuchAlgorithmException { + MessageDigest digest = MessageDigest.getInstance(SHA256); + return digest.digest(arg); + } + + public static byte[] sha256(String arg) throws NoSuchAlgorithmException { + MessageDigest digest = MessageDigest.getInstance(SHA256); + return digest.digest(arg.getBytes(StandardCharsets.UTF_8)); + } + + public static String bytesToHex(byte[] bytes) { + char[] hexChars = new char[bytes.length * 2]; + for ( int i = 0; i < bytes.length; i++ ) { + int v = bytes[i] & 0xFF; + hexChars[i * 2] = hexArray[v >>> 4]; + hexChars[i * 2 + 1] = hexArray[v & 0x0F]; + } + return new String(hexChars); + } + + public static byte[] hexToBytes(String s) { + int len = s.length(); + byte[] data = new byte[len / 2]; + for (int i = 0; i < len; i += 2) { + data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4) + Character.digit(s.charAt(i+1), 16)); + } + return data; + } + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/amino/AminoSerializable.java b/src/main/java/com/binance/dex/api/client/encoding/amino/AminoSerializable.java new file mode 100644 index 0000000..122552d --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/amino/AminoSerializable.java @@ -0,0 +1,16 @@ +package com.binance.dex.api.client.encoding.amino; + +import java.util.ArrayList; + +/** + * @author Fitz.Lu + **/ +public interface AminoSerializable { + + AminoSerializable newAminoMessage(); + + ArrayList> IterateFields(); + + void setValueByFieldIndex(int fieldIndex, Object value); + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/amino/DisambPrefix.java b/src/main/java/com/binance/dex/api/client/encoding/amino/DisambPrefix.java new file mode 100644 index 0000000..3b94326 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/amino/DisambPrefix.java @@ -0,0 +1,65 @@ +package com.binance.dex.api.client.encoding.amino; + +import java.util.Arrays; + +/** + * Disambiguation and prefix pair + * */ +public class DisambPrefix { + + /** + * The first three non-zero bytes + * */ + private byte[] disamb; + + /** + * The first four non-zero bytes + * */ + private byte[] prefix; + + /** + * You know it + * */ + private byte[] disambPrefix; + + public DisambPrefix() { } + + public DisambPrefix(byte[] disamb, byte[] prefix, byte[] disambPrefix) { + this.disamb = disamb; + this.prefix = prefix; + this.disambPrefix = disambPrefix; + } + + public byte[] getDisamb() { + return disamb; + } + + public void setDisamb(byte[] disamb) { + this.disamb = disamb; + } + + public byte[] getPrefix() { + return prefix; + } + + public void setPrefix(byte[] prefix) { + this.prefix = prefix; + } + + public byte[] getDisambPrefix() { + return disambPrefix; + } + + public void setDisambPrefix(byte[] disambPrefix) { + this.disambPrefix = disambPrefix; + } + + @Override + public String toString() { + return "DisambPrefixPair{" + + "disamb=" + Arrays.toString(disamb) + + ", prefix=" + Arrays.toString(prefix) + + ", disambPrefix=" + Arrays.toString(disambPrefix) + + '}'; + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/amino/WireType.java b/src/main/java/com/binance/dex/api/client/encoding/amino/WireType.java new file mode 100644 index 0000000..6cc466f --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/amino/WireType.java @@ -0,0 +1,55 @@ +package com.binance.dex.api.client.encoding.amino; + +import com.binance.dex.api.client.encoding.amino.types.PubKeyEd25519; +import com.binance.dex.api.client.encoding.message.sidechain.transaction.*; +import org.bouncycastle.util.encoders.Hex; + +import java.util.HashMap; +import java.util.Map; + +/** + * @author Fitz.Lu + * @see {https://developers.google.com/protocol-buffers/docs/encoding#structure} + **/ +public class WireType { + + private static final HashMap, String> aminoType; + private static final HashMap> typePrefixMap; + + static { + aminoType = new HashMap<>(); + aminoType.put(PubKeyEd25519.class, "tendermint/PubKeyEd25519"); + aminoType.put(CreateSideChainValidatorMessage.class, "cosmos-sdk/MsgCreateSideChainValidator"); + aminoType.put(EditSideChainValidatorMessage.class, "cosmos-sdk/MsgEditSideChainValidator"); + aminoType.put(SideChainDelegateMessage.class, "cosmos-sdk/MsgSideChainDelegate"); + aminoType.put(SideChainRedelegateMessage.class, "cosmos-sdk/MsgSideChainRedelegate"); + aminoType.put(SideChainUndelegateMessage.class, "cosmos-sdk/MsgSideChainUndelegate"); + + typePrefixMap = new HashMap<>(); + Amino amino = new Amino(); + for (Map.Entry, String> entry : aminoType.entrySet()) { + typePrefixMap.put(amino.nameToPrefixString(entry.getValue()), entry.getKey()); + } + } + + public static int VARINT = 0; //int32, int64, uint32, uint64, sint32, sint64, bool, enum + + public static int BIT64 = 1; //fixed64, sfixed64, double + + public static int LENGTH_DELIMITED = 2; //string, bytes, embedded messages, packed repeated fields + + public static int BIT_32 = 5; // fixed32, sfixed32, float + + public static boolean isRegistered(Class clazz){ + return aminoType.containsKey(clazz); + } + + public static boolean isRegistered(byte[] typePrefix){ + return typePrefixMap.containsKey(Hex.toHexString(typePrefix)); + } + + public static String getRegisteredTypeName(Class clazz){ + return aminoType.get(clazz); + } + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/amino/types/PubKey.java b/src/main/java/com/binance/dex/api/client/encoding/amino/types/PubKey.java new file mode 100644 index 0000000..9d20220 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/amino/types/PubKey.java @@ -0,0 +1,10 @@ +package com.binance.dex.api.client.encoding.amino.types; + +/** + * @author Fitz.Lu + **/ +public interface PubKey { + + byte[] getBytes(); + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/amino/types/PubKeyEd25519.java b/src/main/java/com/binance/dex/api/client/encoding/amino/types/PubKeyEd25519.java new file mode 100644 index 0000000..2aaaefc --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/amino/types/PubKeyEd25519.java @@ -0,0 +1,28 @@ +package com.binance.dex.api.client.encoding.amino.types; + +/** + * @author Fitz.Lu + **/ +public class PubKeyEd25519 implements PubKey { + + private final int keySize = 32; + + private byte[] raw; + + public PubKeyEd25519(byte[] raw) { + this.raw = raw; + } + + public byte[] getRaw() { + return raw; + } + + public void setRaw(byte[] raw) { + this.raw = raw; + } + + @Override + public byte[] getBytes() { + return raw; + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java b/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java index b3bd921..29a24db 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java @@ -32,7 +32,12 @@ public enum MessageType { HashTimerLockTransferMsg("B33F9A24"), DepositHashTimerLockMsg("63986496"), ClaimHashTimerLockMsg("C1665300"), - RefundHashTimerLockMsg("3454A27C"); + RefundHashTimerLockMsg("3454A27C"), + CreateSideChainValidator("D17201E5"), + EditSideChainValidator("264CC57B"), + SideChainDelegate("E3A07FD2"), + SideChainRedelegate("E3CED364"), + SideChainUndelegate("514F7E0E"); private byte[] typePrefixBytes; MessageType(String typePrefix) { diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/Token.java b/src/main/java/com/binance/dex/api/client/encoding/message/Token.java index ddf47e9..8448f41 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/Token.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/Token.java @@ -3,6 +3,7 @@ import com.binance.dex.api.client.BinanceDexConstants; import com.binance.dex.api.proto.Send; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.annotation.JsonPropertyOrder; import org.apache.commons.lang3.builder.ToStringBuilder; @@ -26,6 +27,14 @@ public static Token of(Send.Token sendToken){ return token; } + public Token() { + } + + public Token(String denom, Long amount) { + this.denom = denom; + this.amount = amount; + } + public String getDenom() { return denom; } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/TransactionMessageWithType.java b/src/main/java/com/binance/dex/api/client/encoding/message/TransactionMessageWithType.java new file mode 100644 index 0000000..aad1931 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/TransactionMessageWithType.java @@ -0,0 +1,43 @@ +package com.binance.dex.api.client.encoding.message; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; + +/** + * @author Fitz.Lu + **/ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class TransactionMessageWithType implements BinanceDexTransactionMessage { + + @JsonProperty(value = "type") + private String type; + + @JsonProperty(value = "value") + private T value; + + public TransactionMessageWithType() { + } + + public TransactionMessageWithType(String type, T value) { + this.type = type; + this.value = value; + } + + public String getType() { + return type; + } + + public void setType(String type) { + this.type = type; + } + + public T getValue() { + return value; + } + + public void setValue(T value) { + this.value = value; + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/TransactionRequestAssembler.java b/src/main/java/com/binance/dex/api/client/encoding/message/TransactionRequestAssembler.java index 626a71a..073a23a 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/TransactionRequestAssembler.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/TransactionRequestAssembler.java @@ -2,8 +2,14 @@ import com.binance.dex.api.client.Wallet; import com.binance.dex.api.client.domain.broadcast.*; +import com.binance.dex.api.client.domain.sidechain.*; import com.binance.dex.api.client.encoding.Crypto; import com.binance.dex.api.client.encoding.EncodeUtils; +import com.binance.dex.api.client.encoding.amino.Amino; +import com.binance.dex.api.client.encoding.amino.WireType; +import com.binance.dex.api.client.encoding.message.sidechain.SideChainClassConverter; +import com.binance.dex.api.client.encoding.message.sidechain.transaction.*; +import com.binance.dex.api.client.encoding.message.sidechain.value.*; import com.binance.dex.api.proto.StdSignature; import com.binance.dex.api.proto.StdTx; import com.google.common.annotations.VisibleForTesting; @@ -28,9 +34,12 @@ public class TransactionRequestAssembler { private Wallet wallet; private TransactionOption options; + private final Amino amino; + public TransactionRequestAssembler(Wallet wallet, TransactionOption options) { this.wallet = wallet; this.options = options; + this.amino = new Amino(); } public static long doubleToLong(String d) { @@ -49,6 +58,23 @@ public static String longToDouble(long l) { return BigDecimal.valueOf(l).divide(MULTIPLY_FACTOR).toString(); } + @VisibleForTesting + byte[] signTx(BinanceDexTransactionMessage msg) throws IOException, NoSuchAlgorithmException { + return sign(assembleMessage4Sigh(msg)); + } + + private BinanceDexTransactionMessage assembleMessage4Sigh(T t){ + if (WireType.isRegistered(t.getClass())){ + return new TransactionMessageWithType(WireType.getRegisteredTypeName(t.getClass()), t); + }else{ + if (!BinanceDexTransactionMessage.class.isAssignableFrom(t.getClass())){ + throw new IllegalStateException("sign message should implement BinanceDexTransactionMessage"); + }else{ + return ((BinanceDexTransactionMessage) t); + } + } + } + @VisibleForTesting byte[] sign(BinanceDexTransactionMessage msg) throws NoSuchAlgorithmException, IOException { @@ -64,6 +90,8 @@ byte[] sign(BinanceDexTransactionMessage msg) if (wallet.getEcKey() == null && wallet.getLedgerKey() != null) { return Crypto.sign(EncodeUtils.toJsonEncodeBytes(sd), wallet.getLedgerKey()); } + + String d = new String(EncodeUtils.toJsonEncodeBytes(sd)); return Crypto.sign(EncodeUtils.toJsonEncodeBytes(sd), wallet.getEcKey()); } @@ -551,4 +579,103 @@ public byte[] encodeRefundHtltMessage(RefundHtltMessage msg) throws IOException return EncodeUtils.aminoWrap(proto.toByteArray(), MessageType.RefundHashTimerLockMsg.getTypePrefixBytes(), false); } + @VisibleForTesting + CreateSideChainValidatorMessage createSideChainValidatorMessage(CreateSideChainValidator createSideChainValidator){ + CreateSideChainValidatorMessage message = new CreateSideChainValidatorMessage(); + + if (createSideChainValidator.getDescription() != null){ + message.setDescription(SideChainClassConverter.convert(createSideChainValidator.getDescription())); + } + if (createSideChainValidator.getCommission() != null){ + message.setCommission(SideChainClassConverter.convert(createSideChainValidator.getCommission())); + } + + message.setDelegatorAddr(AddressValue.from(createSideChainValidator.getDelegatorAddr())); + + if (createSideChainValidator.getDelegation() != null){ + message.setDelegation(SideChainClassConverter.convert(createSideChainValidator.getDelegation())); + } + + message.setSideChainId(createSideChainValidator.getSideChainId()); + message.setSideConsAddr(decodeHexAddress(createSideChainValidator.getSideConsAddr())); + message.setSideFeeAddr(decodeHexAddress(createSideChainValidator.getSideFeeAddr())); + return message; + } + + @VisibleForTesting + byte[] encodeCreateSideChainValidatorMessage(CreateSideChainValidatorMessage message) throws IOException { + return amino.encode(message, MessageType.CreateSideChainValidator.getTypePrefixBytes(), false); + } + + @VisibleForTesting + public String buildCreateSideChainValidatorPayload(CreateSideChainValidator createSideChainValidator) throws IOException, NoSuchAlgorithmException { + CreateSideChainValidatorMessage message = createSideChainValidatorMessage(createSideChainValidator); + message.setValidatorOperatorAddr(AddressValue.from(wallet.getAddress())); + byte[] msg = encodeCreateSideChainValidatorMessage(message); + byte[] signature = encodeSignature(signTx(message)); + byte[] stdTx = encodeStdTx(msg, signature); + return EncodeUtils.bytesToHex(stdTx); + } + + @VisibleForTesting + EditSideChainValidatorMessage createEditSideChainValidatorMessage(EditSideChainValidator editSideChainValidator){ + EditSideChainValidatorMessage message = new EditSideChainValidatorMessage(); + + if (editSideChainValidator.getDescription() != null){ + message.setDescription(SideChainClassConverter.convert(editSideChainValidator.getDescription())); + } + + message.setCommissionRate(Dec.newInstance(editSideChainValidator.getCommissionRate())); + message.setSideChainId(editSideChainValidator.getSideChainId()); + message.setSideFeeAddr(decodeHexAddress(editSideChainValidator.getSideFeeAddr())); + + return message; + } + + @VisibleForTesting + byte[] encodeEditSideChainValidatorMessage(EditSideChainValidatorMessage message) throws IOException { + return amino.encode(message, MessageType.EditSideChainValidator.getTypePrefixBytes(), false); + } + + public String buildEditSideChainValidatorPayload(EditSideChainValidator editSideChainValidator) throws IOException, NoSuchAlgorithmException { + EditSideChainValidatorMessage message = createEditSideChainValidatorMessage(editSideChainValidator); + message.setValidatorOperatorAddress(AddressValue.from(wallet.getAddress())); + byte[] msg = encodeEditSideChainValidatorMessage(message); + byte[] signature = encodeSignature(signTx(message)); + byte[] stdTx = encodeStdTx(msg, signature); + return EncodeUtils.bytesToHex(stdTx); + } + + public String buildSideChainDelegatePayload(SideChainDelegate sideChainDelegate) throws IOException, NoSuchAlgorithmException { + SideChainDelegateMessage message = SideChainClassConverter.convert(sideChainDelegate); + byte[] msg = amino.encode(message, MessageType.SideChainDelegate.getTypePrefixBytes(), false); + byte[] signature = encodeSignature(signTx(message)); + byte[] stdTx = encodeStdTx(msg, signature); + return EncodeUtils.bytesToHex(stdTx); + } + + public String buildSideChainRedelegatePayload(SideChainRedelegate sideChainRedelegate) throws IOException, NoSuchAlgorithmException { + SideChainRedelegateMessage message = SideChainClassConverter.convert(sideChainRedelegate); + byte[] msg = amino.encode(message, MessageType.SideChainRedelegate.getTypePrefixBytes(), false); + byte[] signature = encodeSignature(signTx(message)); + byte[] stdTx = encodeStdTx(msg, signature); + return EncodeUtils.bytesToHex(stdTx); + } + + public String buildSideChainUndelegatePayload(SideChainUnBond sideChainUndelegate) throws IOException, NoSuchAlgorithmException { + SideChainUndelegateMessage message = SideChainClassConverter.convert(sideChainUndelegate); + byte[] msg = amino.encode(message, MessageType.SideChainUndelegate.getTypePrefixBytes(), false); + byte[] signature = encodeSignature(signTx(message)); + byte[] stdTx = encodeStdTx(msg, signature); + return EncodeUtils.bytesToHex(stdTx); + } + + private byte[] decodeHexAddress(String address){ + String addr = address; + if (addr.startsWith("0x")){ + addr = address.substring(2); + } + return Hex.decode(addr); + } + } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/SideChainClassConverter.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/SideChainClassConverter.java new file mode 100644 index 0000000..f8cac48 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/SideChainClassConverter.java @@ -0,0 +1,75 @@ +package com.binance.dex.api.client.encoding.message.sidechain; + +import com.binance.dex.api.client.domain.sidechain.*; +import com.binance.dex.api.client.encoding.message.Token; +import com.binance.dex.api.client.encoding.message.sidechain.transaction.SideChainDelegateMessage; +import com.binance.dex.api.client.encoding.message.sidechain.transaction.SideChainRedelegateMessage; +import com.binance.dex.api.client.encoding.message.sidechain.transaction.SideChainUndelegateMessage; +import com.binance.dex.api.client.encoding.message.sidechain.value.*; + +/** + * @author Fitz.Lu + **/ +public class SideChainClassConverter { + + public static DescriptionValue convert(Description description){ + DescriptionValue value = new DescriptionValue(); + value.setMoniker(description.getMoniker()); + value.setDetails(description.getDetails()); + value.setIdentity(description.getIdentity()); + value.setWebsite(description.getWebsite()); + return value; + } + + public static CommissionMsgValue convert(Commission commission){ + CommissionMsgValue value = new CommissionMsgValue(); + value.setRate(Dec.newInstance(commission.getRate())); + value.setMaxRate(Dec.newInstance(commission.getMaxRate())); + value.setMaxChangeRate(Dec.newInstance(commission.getMaxChangeRate())); + return value; + } + + public static CoinValue convert(Token token){ + CoinValue value = new CoinValue(); + value.setDenom(token.getDenom()); + value.setAmount(token.getAmount()); + return value; + } + + public static SideChainDelegateMessage convert(SideChainDelegate sideChainDelegate){ + SideChainDelegateMessage message = new SideChainDelegateMessage(); + message.setDelegatorAddress(AddressValue.from(sideChainDelegate.getDelegatorAddress())); + message.setValidatorAddress(AddressValue.from(sideChainDelegate.getValidatorAddress())); + + if (sideChainDelegate.getDelegation() != null) { + message.setDelegation(convert(sideChainDelegate.getDelegation())); + } + + message.setSideChainId(sideChainDelegate.getSideChainId()); + return message; + } + + public static SideChainRedelegateMessage convert(SideChainRedelegate redelegate){ + SideChainRedelegateMessage message = new SideChainRedelegateMessage(); + message.setDelegatorAddress(AddressValue.from(redelegate.getDelegatorAddress())); + message.setSrcValidatorAddress(AddressValue.from(redelegate.getSrcValidatorAddress())); + message.setDstValidatorAddress(AddressValue.from(redelegate.getDstValidatorAddress())); + if (redelegate.getAmount() != null) { + message.setAmount(convert(redelegate.getAmount())); + } + message.setSideChainId(redelegate.getSideChainId()); + return message; + } + + public static SideChainUndelegateMessage convert(SideChainUnBond unBond){ + SideChainUndelegateMessage message = new SideChainUndelegateMessage(); + message.setDelegatorAddress(AddressValue.from(unBond.getDelegatorAddress())); + message.setValidatorAddress(AddressValue.from(unBond.getValidatorAddress())); + if (unBond.getAmount() != null) { + message.setAmount(convert(unBond.getAmount())); + } + message.setSideChainId(unBond.getSideChainId()); + return message; + } + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/BechValidator.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/BechValidator.java new file mode 100644 index 0000000..41cc16f --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/BechValidator.java @@ -0,0 +1,316 @@ +package com.binance.dex.api.client.encoding.message.sidechain.query; + +import com.binance.dex.api.client.domain.sidechain.Commission; +import com.binance.dex.api.client.domain.sidechain.Description; +import com.binance.dex.api.client.domain.sidechain.SideChainValidator; +import com.binance.dex.api.client.encoding.Crypto; +import com.binance.dex.api.client.encoding.amino.Amino; +import com.binance.dex.api.client.encoding.message.sidechain.value.DescriptionValue; +import com.fasterxml.jackson.annotation.JsonProperty; +import org.apache.commons.lang3.StringUtils; + +/** + * @author Fitz.Lu + **/ +public class BechValidator { + + static class CommissionForDecode { + + @JsonProperty(value = "rate") + private long rate; + + @JsonProperty(value = "max_rate") + private long maxRate; + + @JsonProperty(value = "max_change_rate") + private long maxChangeRate; + + @JsonProperty(value = "update_time") + private String updateTime; + + public CommissionForDecode() { + } + + public long getRate() { + return rate; + } + + public void setRate(long rate) { + this.rate = rate; + } + + public long getMaxRate() { + return maxRate; + } + + public void setMaxRate(long maxRate) { + this.maxRate = maxRate; + } + + public long getMaxChangeRate() { + return maxChangeRate; + } + + public void setMaxChangeRate(long maxChangeRate) { + this.maxChangeRate = maxChangeRate; + } + + public String getUpdateTime() { + return updateTime; + } + + public void setUpdateTime(String updateTime) { + this.updateTime = updateTime; + } + } + + @JsonProperty(value = "fee_addr") + private String feeAddr; + + @JsonProperty(value = "operator_address") + private String operatorAddr; + + @JsonProperty(value = "consensus_pubkey") + private String consPubKey; + + @JsonProperty(value = "jailed") + private boolean jailed; + + @JsonProperty(value = "status") + private int status; + + @JsonProperty(value = "tokens") + private long tokens; + + @JsonProperty(value = "delegator_shares") + private long delegatorShares; + + @JsonProperty(value = "description") + private DescriptionValue description; + + @JsonProperty(value = "bond_height") + private long bondHeight; + + @JsonProperty(value = "bond_intra_tx_counter") + private int bondIntraTxCounter; + + @JsonProperty(value = "unbonding_height") + private long unBondingHeight; + + @JsonProperty(value = "unbonding_time") + private String unBondingMinTime; + + @JsonProperty(value = "commission") + private CommissionForDecode commission; + + @JsonProperty(value = "distribution_addr") + private String distributionAddr; + + @JsonProperty(value = "side_chain_id") + private String sideChainId; + + @JsonProperty(value = "side_cons_addr") + private String sideConsAddr; + + @JsonProperty(value = "side_fee_addr") + private String sideFeeAddr; + + public BechValidator() { + } + + + public SideChainValidator toSideChainValidator() { + SideChainValidator validator = new SideChainValidator(); + if (feeAddr != null) { + validator.setFeeAddr(Crypto.decodeAddress(feeAddr)); + } + if (operatorAddr != null) { + validator.setOperatorAddr(Crypto.decodeAddress(operatorAddr)); + } + if (consPubKey != null) { + try { + validator.setConsPubKey(Amino.getByteArrayAfterTypePrefix(consPubKey.getBytes())); + }catch (IllegalStateException e){ + validator.setConsPubKey(consPubKey.getBytes()); + } + } + validator.setJailed(jailed); + validator.setStatus(status); + validator.setTokens(tokens); + validator.setDelegatorShares(delegatorShares); + + Description descript = new Description(); + if (description != null) { + descript.setMoniker(description.getMoniker()); + descript.setWebsite(description.getWebsite()); + descript.setDetails(description.getDetails()); + descript.setIdentity(description.getIdentity()); + } + validator.setDescription(descript); + + validator.setBondHeight(bondHeight); + validator.setBondIntraTxCounter(bondIntraTxCounter); + validator.setUnBondingHeight(unBondingHeight); +// validator.setUnBondingMinTime(unBondingMinTime); + + Commission comm = new Commission(); + if (commission != null) { + comm.setRate(commission.getRate()); + comm.setMaxRate(commission.getMaxRate()); + comm.setMaxChangeRate(commission.getMaxChangeRate()); +// comm.setUpdateTimeInMs(commission.getUpdateTime()); + } + validator.setCommission(comm); + + if (!StringUtils.isEmpty(sideChainId)) { + if (distributionAddr != null) { + validator.setDistributionAddr(distributionAddr.getBytes()); + } + validator.setSideChainId(sideChainId); + if (sideConsAddr != null) { + validator.setSideConsAddr(sideConsAddr.getBytes()); + } + if (sideFeeAddr != null) { + validator.setSideFeeAddr(sideFeeAddr.getBytes()); + } + } + + return validator; + } + + public String getConsPubKey() { + return consPubKey; + } + + public void setConsPubKey(String consPubKey) { + this.consPubKey = consPubKey; + } + + public boolean isJailed() { + return jailed; + } + + public void setJailed(boolean jailed) { + this.jailed = jailed; + } + + public int getStatus() { + return status; + } + + public void setStatus(int status) { + this.status = status; + } + + public long getTokens() { + return tokens; + } + + public void setTokens(long tokens) { + this.tokens = tokens; + } + + public long getDelegatorShares() { + return delegatorShares; + } + + public void setDelegatorShares(long delegatorShares) { + this.delegatorShares = delegatorShares; + } + + public long getBondHeight() { + return bondHeight; + } + + public void setBondHeight(long bondHeight) { + this.bondHeight = bondHeight; + } + + public int getBondIntraTxCounter() { + return bondIntraTxCounter; + } + + public void setBondIntraTxCounter(int bondIntraTxCounter) { + this.bondIntraTxCounter = bondIntraTxCounter; + } + + public long getUnBondingHeight() { + return unBondingHeight; + } + + public void setUnBondingHeight(long unBondingHeight) { + this.unBondingHeight = unBondingHeight; + } + + public String getUnBondingMinTime() { + return unBondingMinTime; + } + + public void setUnBondingMinTime(String unBondingMinTime) { + this.unBondingMinTime = unBondingMinTime; + } + + public DescriptionValue getDescription() { + return description; + } + + public void setDescription(DescriptionValue description) { + this.description = description; + } + + public CommissionForDecode getCommission() { + return commission; + } + + public void setCommission(CommissionForDecode commission) { + this.commission = commission; + } + + public String getSideChainId() { + return sideChainId; + } + + public void setSideChainId(String sideChainId) { + this.sideChainId = sideChainId; + } + + public String getSideConsAddr() { + return sideConsAddr; + } + + public void setSideConsAddr(String sideConsAddr) { + this.sideConsAddr = sideConsAddr; + } + + public String getSideFeeAddr() { + return sideFeeAddr; + } + + public void setSideFeeAddr(String sideFeeAddr) { + this.sideFeeAddr = sideFeeAddr; + } + + public String getFeeAddr() { + return feeAddr; + } + + public void setFeeAddr(String feeAddr) { + this.feeAddr = feeAddr; + } + + public String getOperatorAddr() { + return operatorAddr; + } + + public void setOperatorAddr(String operatorAddr) { + this.operatorAddr = operatorAddr; + } + + public String getDistributionAddr() { + return distributionAddr; + } + + public void setDistributionAddr(String distributionAddr) { + this.distributionAddr = distributionAddr; + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryTopValidatorParams.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryTopValidatorParams.java new file mode 100644 index 0000000..0d7189c --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryTopValidatorParams.java @@ -0,0 +1,34 @@ +package com.binance.dex.api.client.encoding.message.sidechain.query; + +import com.fasterxml.jackson.annotation.JsonProperty; + +/** + * @author Fitz.Lu + **/ +public class QueryTopValidatorParams { + + @JsonProperty(value = "SideChainId") + private String sideChainId; + + @JsonProperty(value = "Top") + private int top; + + public QueryTopValidatorParams() { + } + + public String getSideChainId() { + return sideChainId; + } + + public void setSideChainId(String sideChainId) { + this.sideChainId = sideChainId; + } + + public int getTop() { + return top; + } + + public void setTop(int top) { + this.top = top; + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/SideChainRedelegationMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/SideChainRedelegationMessage.java new file mode 100644 index 0000000..cf307b8 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/SideChainRedelegationMessage.java @@ -0,0 +1,163 @@ +package com.binance.dex.api.client.encoding.message.sidechain.query; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.sidechain.value.CoinValue; +import com.binance.dex.api.client.encoding.message.sidechain.value.Dec; +import com.binance.dex.api.client.encoding.message.sidechain.value.TimestampValue; + +import java.util.ArrayList; + +/** + * @author Fitz.Lu + **/ +public class SideChainRedelegationMessage implements AminoSerializable { + + private byte[] delegatorAddress; + + private byte[] srcValidatorAddress; + + private byte[] dstValidatorAddress; + + private long createHeight; + + private TimestampValue minTime = new TimestampValue(); + + private CoinValue initialBalance = new CoinValue(); + + private CoinValue balance = new CoinValue(); + + private Dec srcShares = new Dec(); + + private Dec dstShare = new Dec(); + + public SideChainRedelegationMessage() { + } + + public byte[] getDelegatorAddress() { + return delegatorAddress; + } + + public void setDelegatorAddress(byte[] delegatorAddress) { + this.delegatorAddress = delegatorAddress; + } + + public byte[] getSrcValidatorAddress() { + return srcValidatorAddress; + } + + public void setSrcValidatorAddress(byte[] srcValidatorAddress) { + this.srcValidatorAddress = srcValidatorAddress; + } + + public byte[] getDstValidatorAddress() { + return dstValidatorAddress; + } + + public void setDstValidatorAddress(byte[] dstValidatorAddress) { + this.dstValidatorAddress = dstValidatorAddress; + } + + public long getCreateHeight() { + return createHeight; + } + + public void setCreateHeight(long createHeight) { + this.createHeight = createHeight; + } + + public TimestampValue getMinTime() { + return minTime; + } + + public void setMinTime(TimestampValue minTime) { + this.minTime = minTime; + } + + public CoinValue getInitialBalance() { + return initialBalance; + } + + public void setInitialBalance(CoinValue initialBalance) { + this.initialBalance = initialBalance; + } + + public CoinValue getBalance() { + return balance; + } + + public void setBalance(CoinValue balance) { + this.balance = balance; + } + + public Dec getSrcShares() { + return srcShares; + } + + public void setSrcShares(Dec srcShares) { + this.srcShares = srcShares; + } + + public Dec getDstShare() { + return dstShare; + } + + public void setDstShare(Dec dstShare) { + this.dstShare = dstShare; + } + + @Override + public AminoSerializable newAminoMessage() { + return new SideChainRedelegationMessage(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(byte[].class, delegatorAddress, delegatorAddress == null || delegatorAddress.length == 0) + .addField(byte[].class, srcValidatorAddress, srcValidatorAddress == null || srcValidatorAddress.length == 0) + .addField(byte[].class, dstValidatorAddress, dstValidatorAddress == null || dstValidatorAddress.length == 0) + .addField(Long.class, createHeight, createHeight == 0) + .addField(TimestampValue.class, minTime, minTime == null) + .addField(CoinValue.class, initialBalance, initialBalance == null) + .addField(CoinValue.class, balance, balance == null) + .addField(Dec.class, srcShares, srcShares == null || srcShares.isDefaultOrEmpty()) + .addField(Dec.class, dstShare, dstShare == null || dstShare.isDefaultOrEmpty()) + .build(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + delegatorAddress = ((byte[]) value); + break; + case 2: + srcValidatorAddress = ((byte[]) value); + break; + case 3: + dstValidatorAddress = ((byte[]) value); + break; + case 4: + createHeight = ((long) value); + break; + case 5: + minTime = ((TimestampValue) value); + break; + case 6: + initialBalance = ((CoinValue) value); + break; + case 7: + balance = ((CoinValue) value); + break; + case 8: + srcShares = ((Dec) value); + break; + case 9: + dstShare = ((Dec) value); + break; + default: + break; + } + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/SideChainUnBondingDelegationMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/SideChainUnBondingDelegationMessage.java new file mode 100644 index 0000000..a512231 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/SideChainUnBondingDelegationMessage.java @@ -0,0 +1,69 @@ +package com.binance.dex.api.client.encoding.message.sidechain.query; + +import com.binance.dex.api.client.encoding.ByteUtil; +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.sidechain.value.CoinValue; + +import java.util.ArrayList; + +/** + * @author Fitz.Lu + **/ +public class SideChainUnBondingDelegationMessage implements AminoSerializable { + + private byte[] delegatorAddress; + + private byte[] validatorAddress; + + private long createHeight; + + private long minTimeInMs; + + private CoinValue initialBalance = new CoinValue(); + + private CoinValue balance = new CoinValue(); + + @Override + public AminoSerializable newAminoMessage() { + return new SideChainUnBondingDelegationMessage(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(byte[].class, delegatorAddress, ByteUtil.isEmpty(delegatorAddress)) + .addField(byte[].class, validatorAddress, ByteUtil.isEmpty(validatorAddress)) + .addField(Long.class, createHeight, createHeight == 0) + .addField(Long.class, minTimeInMs, minTimeInMs == 0) + .addField(CoinValue.class, initialBalance, initialBalance == null) + .addField(CoinValue.class, balance, balance == null) + .build(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + delegatorAddress = ((byte[]) value); + break; + case 2: + validatorAddress = ((byte[]) value); + break; + case 3: + createHeight = ((Integer) value); + break; + case 4: + minTimeInMs = ((Long) value); + break; + case 5: + initialBalance = ((CoinValue) value); + break; + case 6: + balance = ((CoinValue) value); + break; + default: + break; + } + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/SideChainValidatorMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/SideChainValidatorMessage.java new file mode 100644 index 0000000..0380d7c --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/SideChainValidatorMessage.java @@ -0,0 +1,298 @@ +package com.binance.dex.api.client.encoding.message.sidechain.query; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.sidechain.value.CommissionValue; +import com.binance.dex.api.client.encoding.message.sidechain.value.Dec; +import com.binance.dex.api.client.encoding.message.sidechain.value.DescriptionValue; +import org.apache.commons.lang3.StringUtils; +import org.bouncycastle.util.encoders.Hex; + +import java.util.ArrayList; +import java.util.Arrays; + +/** + * @author Fitz.Lu + **/ +public class SideChainValidatorMessage implements AminoSerializable { + + private byte[] feeAddr; + + private byte[] operatorAddr; + + private byte[] consPubKey; + + private boolean jailed; + + private int status; + + private Dec tokens = Dec.newInstance(0L); + + private Dec delegatorShares = Dec.newInstance(0L); + + private DescriptionValue description = new DescriptionValue(); + + private long bondHeight; + + private int bondIntraTxCounter; + + private long unBondingHeight; + + private long unBondingMinTime; + + private CommissionValue commission = new CommissionValue(); + + private byte[] distributionAddr; + + private String sideChainId; + + private byte[] sideConsAddr; + + private byte[] sideFeeAddr; + + public byte[] getFeeAddr() { + return feeAddr; + } + + public void setFeeAddr(byte[] feeAddr) { + this.feeAddr = feeAddr; + } + + public byte[] getOperatorAddr() { + return operatorAddr; + } + + public void setOperatorAddr(byte[] operatorAddr) { + this.operatorAddr = operatorAddr; + } + + public byte[] getConsPubKey() { + return consPubKey; + } + + public void setConsPubKey(byte[] consPubKey) { + this.consPubKey = consPubKey; + } + + public boolean isJailed() { + return jailed; + } + + public void setJailed(boolean jailed) { + this.jailed = jailed; + } + + public int getStatus() { + return status; + } + + public void setStatus(int status) { + this.status = status; + } + + public Dec getTokens() { + return tokens; + } + + public void setTokens(Dec tokens) { + this.tokens = tokens; + } + + public Dec getDelegatorShares() { + return delegatorShares; + } + + public void setDelegatorShares(Dec delegatorShares) { + this.delegatorShares = delegatorShares; + } + + public DescriptionValue getDescription() { + return description; + } + + public void setDescription(DescriptionValue description) { + this.description = description; + } + + public long getBondHeight() { + return bondHeight; + } + + public void setBondHeight(long bondHeight) { + this.bondHeight = bondHeight; + } + + public int getBondIntraTxCounter() { + return bondIntraTxCounter; + } + + public void setBondIntraTxCounter(int bondIntraTxCounter) { + this.bondIntraTxCounter = bondIntraTxCounter; + } + + public long getUnBondingHeight() { + return unBondingHeight; + } + + public void setUnBondingHeight(long unBondingHeight) { + this.unBondingHeight = unBondingHeight; + } + + public long getUnBondingMinTime() { + return unBondingMinTime; + } + + public void setUnBondingMinTime(long unBondingMinTime) { + this.unBondingMinTime = unBondingMinTime; + } + + public CommissionValue getCommission() { + return commission; + } + + public void setCommission(CommissionValue commission) { + this.commission = commission; + } + + public byte[] getDistributionAddr() { + return distributionAddr; + } + + public void setDistributionAddr(byte[] distributionAddr) { + this.distributionAddr = distributionAddr; + } + + public String getSideChainId() { + return sideChainId; + } + + public void setSideChainId(String sideChainId) { + this.sideChainId = sideChainId; + } + + public byte[] getSideConsAddr() { + return sideConsAddr; + } + + public void setSideConsAddr(byte[] sideConsAddr) { + this.sideConsAddr = sideConsAddr; + } + + public byte[] getSideFeeAddr() { + return sideFeeAddr; + } + + public void setSideFeeAddr(byte[] sideFeeAddr) { + this.sideFeeAddr = sideFeeAddr; + } + + @Override + public AminoSerializable newAminoMessage() { + return new SideChainValidatorMessage(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + feeAddr = (byte[]) value; + break; + case 2: + operatorAddr = (byte[]) value; + break; + case 3: + consPubKey = (byte[]) value; + break; + case 4: + jailed = ((boolean) value); + break; + case 5: + status = ((Integer) value); + break; + case 6: + tokens = ((Dec) value); + break; + case 7: + delegatorShares = ((Dec) value); + break; + case 8: + description = ((DescriptionValue) value); + break; + case 9: + bondHeight = ((long) value); + break; + case 10: + bondIntraTxCounter = ((int) value); + break; + case 11: + unBondingHeight = ((long) value); + break; + case 12: + unBondingMinTime = ((long) value); + break; + case 13: + commission = ((CommissionValue) value); + break; + case 14: + distributionAddr = ((byte[]) value); + break; + case 15: + sideChainId = ((String) value); + break; + case 16: + sideConsAddr = ((byte[]) value); + break; + case 17: + sideFeeAddr = ((byte[]) value); + break; + default: + break; + } + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(byte[].class, feeAddr, feeAddr == null || feeAddr.length == 0) + .addField(byte[].class, operatorAddr, operatorAddr == null || operatorAddr.length == 0) + .addField(byte[].class, consPubKey, consPubKey == null || consPubKey.length == 0) + .addField(Boolean.class, jailed, !jailed) + .addField(Integer.class, status, status == 0) + .addField(Dec.class, tokens, tokens == null) + .addField(Dec.class, delegatorShares, delegatorShares == null) + .addField(DescriptionValue.class, description, description == null) + .addField(Long.class, bondHeight, bondHeight == 0) + .addField(Integer.class, bondIntraTxCounter, bondIntraTxCounter == 0) + .addField(Long.class, unBondingHeight, unBondingHeight == 0) + .addField(Long.class, unBondingMinTime, unBondingMinTime == 0) + .addField(CommissionValue.class, commission, commission == null) + .addField(byte[].class, distributionAddr, distributionAddr == null || distributionAddr.length == 0) + .addField(String.class, sideChainId, StringUtils.isEmpty(sideChainId)) + .addField(byte[].class, sideConsAddr, sideConsAddr == null || sideConsAddr.length == 0) + .addField(byte[].class, sideFeeAddr, sideFeeAddr == null || sideFeeAddr.length == 0) + .build(); + } + + @Override + public String toString() { + return "SideChainValidatorMessage{" + '\n' + + "feeAddr=" + Hex.toHexString(feeAddr)+ '\n' + + ", operatorAddr=" + Hex.toHexString(operatorAddr) + '\n' + + ", consPubKey=" + Hex.toHexString(consPubKey) + '\n' + + ", jailed=" + jailed + '\n' + + ", status=" + status + '\n' + + ", tokens=" + tokens + '\n' + + ", delegatorShares=" + delegatorShares + '\n' + + ", description=" + description + '\n' + + ", bondHeight=" + bondHeight + '\n' + + ", bondIntraTxCounter=" + bondIntraTxCounter + '\n' + + ", unBondingHeight=" + unBondingHeight + '\n' + + ", unBondingMinTime=" + unBondingMinTime + '\n' + + ", commission=" + commission + '\n' + + ", distributionAddr=" + Arrays.toString(distributionAddr) + '\n' + + ", sideChainId='" + sideChainId + '\'' + '\n' + + ", sideConsAddr=" + Arrays.toString(sideConsAddr) + '\n' + + ", sideFeeAddr=" + Arrays.toString(sideFeeAddr) + '\n' + + '}'; + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/CreateSideChainValidatorMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/CreateSideChainValidatorMessage.java new file mode 100644 index 0000000..4ee860d --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/CreateSideChainValidatorMessage.java @@ -0,0 +1,162 @@ +package com.binance.dex.api.client.encoding.message.sidechain.transaction; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; +import com.binance.dex.api.client.encoding.message.sidechain.value.*; +import com.binance.dex.api.client.encoding.serializer.AccAddressValueToStringSerializer; +import com.binance.dex.api.client.encoding.serializer.ValAddressValueToStringSerializer; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import org.apache.commons.lang3.StringUtils; + +import java.util.ArrayList; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class CreateSideChainValidatorMessage implements BinanceDexTransactionMessage, AminoSerializable { + + @JsonProperty(value = "description") + private DescriptionValue description = new DescriptionValue(); + + @JsonProperty(value = "commission") + private CommissionMsgValue commission = new CommissionMsgValue(); + + @JsonProperty(value = "delegator_address") + @JsonSerialize(using = AccAddressValueToStringSerializer.class) + private AddressValue delegatorAddr; + + @JsonProperty(value = "validator_address") + @JsonSerialize(using = ValAddressValueToStringSerializer.class) + private AddressValue validatorOperatorAddr; + + @JsonProperty(value = "delegation") + private CoinValue delegation; + + @JsonProperty(value = "side_chain_id") + private String sideChainId; + + @JsonProperty(value = "side_cons_addr") + private byte[] sideConsAddr; + + @JsonProperty(value = "side_fee_addr") + private byte[] sideFeeAddr; + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + description = ((DescriptionValue) value); + break; + case 2: + commission = ((CommissionMsgValue) value); + break; + case 3: + delegatorAddr = ((AddressValue) value); + break; + case 4: + validatorOperatorAddr = ((AddressValue) value); + break; + case 5: + delegation = ((CoinValue) value); + break; + case 6: + sideChainId = ((String) value); + break; + case 7: + sideConsAddr = ((byte[]) value); + break; + case 8: + sideFeeAddr = ((byte[]) value); + break; + default: + break; + } + } + + @Override + public AminoSerializable newAminoMessage() { + return new CreateSideChainValidatorMessage(); + } + + @Override + public ArrayList> IterateFields() { + ArrayList> fields = new ArrayList<>(); + fields.add(new AminoField<>(DescriptionValue.class, description, description == null)); + fields.add(new AminoField<>(CommissionMsgValue.class, commission, commission == null)); + fields.add(new AminoField<>(AddressValue.class, delegatorAddr, delegatorAddr == null || delegatorAddr.isDefaultOrEmpty())); + fields.add(new AminoField<>(AddressValue.class, validatorOperatorAddr, validatorOperatorAddr == null || validatorOperatorAddr.isDefaultOrEmpty())); + fields.add(new AminoField<>(CoinValue.class, delegation, delegation == null)); + fields.add(new AminoField<>(String.class, sideChainId, StringUtils.isEmpty(sideChainId))); + fields.add(new AminoField<>(byte[].class, sideConsAddr, sideConsAddr == null || sideConsAddr.length == 0)); + fields.add(new AminoField<>(byte[].class, sideFeeAddr, sideFeeAddr == null || sideFeeAddr.length == 0)); + return fields; + } + + public DescriptionValue getDescription() { + return description; + } + + public void setDescription(DescriptionValue description) { + this.description = description; + } + + public CommissionMsgValue getCommission() { + return commission; + } + + public void setCommission(CommissionMsgValue commission) { + this.commission = commission; + } + + public AddressValue getDelegatorAddr() { + return delegatorAddr; + } + + public void setDelegatorAddr(AddressValue delegatorAddr) { + this.delegatorAddr = delegatorAddr; + } + + public AddressValue getValidatorOperatorAddr() { + return validatorOperatorAddr; + } + + public void setValidatorOperatorAddr(AddressValue validatorOperatorAddr) { + this.validatorOperatorAddr = validatorOperatorAddr; + } + + public CoinValue getDelegation() { + return delegation; + } + + public void setDelegation(CoinValue delegation) { + this.delegation = delegation; + } + + public String getSideChainId() { + return sideChainId; + } + + public void setSideChainId(String sideChainId) { + this.sideChainId = sideChainId; + } + + public byte[] getSideConsAddr() { + return sideConsAddr; + } + + public void setSideConsAddr(byte[] sideConsAddr) { + this.sideConsAddr = sideConsAddr; + } + + public byte[] getSideFeeAddr() { + return sideFeeAddr; + } + + public void setSideFeeAddr(byte[] sideFeeAddr) { + this.sideFeeAddr = sideFeeAddr; + } + +} \ No newline at end of file diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/EditSideChainValidatorMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/EditSideChainValidatorMessage.java new file mode 100644 index 0000000..011091e --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/EditSideChainValidatorMessage.java @@ -0,0 +1,107 @@ +package com.binance.dex.api.client.encoding.message.sidechain.transaction; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; +import com.binance.dex.api.client.encoding.message.sidechain.value.AddressValue; +import com.binance.dex.api.client.encoding.message.sidechain.value.Dec; +import com.binance.dex.api.client.encoding.message.sidechain.value.DescriptionValue; +import com.binance.dex.api.client.encoding.serializer.DecToStringSerializer; +import com.binance.dex.api.client.encoding.serializer.ValAddressValueToStringSerializer; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import org.apache.commons.lang3.StringUtils; + +import java.util.ArrayList; + +/** + * @author Fitz.Lu + **/ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class EditSideChainValidatorMessage implements BinanceDexTransactionMessage, AminoSerializable { + + @JsonProperty(value = "description") + private DescriptionValue description; + + @JsonProperty(value = "address") + @JsonSerialize(using = ValAddressValueToStringSerializer.class) + private AddressValue validatorOperatorAddress; + + @JsonProperty(value = "commission_rate") + @JsonSerialize(using = DecToStringSerializer.class) + private Dec commissionRate; + + @JsonProperty(value = "side_chain_id") + private String sideChainId; + + @JsonProperty(value = "side_fee_addr") + private byte[] sideFeeAddr; + + public EditSideChainValidatorMessage() { + } + + public DescriptionValue getDescription() { + return description; + } + + public void setDescription(DescriptionValue description) { + this.description = description; + } + + public AddressValue getValidatorOperatorAddress() { + return validatorOperatorAddress; + } + + public void setValidatorOperatorAddress(AddressValue validatorOperatorAddress) { + this.validatorOperatorAddress = validatorOperatorAddress; + } + + public Dec getCommissionRate() { + return commissionRate; + } + + public void setCommissionRate(Dec commissionRate) { + this.commissionRate = commissionRate; + } + + public String getSideChainId() { + return sideChainId; + } + + public void setSideChainId(String sideChainId) { + this.sideChainId = sideChainId; + } + + public byte[] getSideFeeAddr() { + return sideFeeAddr; + } + + public void setSideFeeAddr(byte[] sideFeeAddr) { + this.sideFeeAddr = sideFeeAddr; + } + + @Override + public AminoSerializable newAminoMessage() { + return new EditSideChainValidatorMessage(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(DescriptionValue.class, description, description == null) + .addField(AddressValue.class, validatorOperatorAddress, validatorOperatorAddress == null || validatorOperatorAddress.isDefaultOrEmpty()) + .addField(Dec.class, commissionRate, commissionRate == null || commissionRate.isDefaultOrEmpty()) + .addField(String.class, sideChainId, StringUtils.isEmpty(sideChainId)) + .addField(byte[].class, sideFeeAddr, sideFeeAddr == null || sideFeeAddr.length == 0) + .build(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + + } + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainDelegateMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainDelegateMessage.java new file mode 100644 index 0000000..c2f9657 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainDelegateMessage.java @@ -0,0 +1,108 @@ +package com.binance.dex.api.client.encoding.message.sidechain.transaction; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; +import com.binance.dex.api.client.encoding.message.sidechain.value.AddressValue; +import com.binance.dex.api.client.encoding.message.sidechain.value.CoinValue; +import com.binance.dex.api.client.encoding.serializer.AccAddressValueToStringSerializer; +import com.binance.dex.api.client.encoding.serializer.ValAddressValueToStringSerializer; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import org.apache.commons.lang3.StringUtils; + +import java.util.ArrayList; + +/** + * @author Fitz.Lu + **/ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class SideChainDelegateMessage implements BinanceDexTransactionMessage, AminoSerializable { + + @JsonProperty(value = "delegator_addr") + @JsonSerialize(using = AccAddressValueToStringSerializer.class) + private AddressValue delegatorAddress; + + @JsonProperty(value = "validator_addr") + @JsonSerialize(using = ValAddressValueToStringSerializer.class) + private AddressValue validatorAddress; + + @JsonProperty(value = "delegation") + private CoinValue delegation; + + @JsonProperty(value = "side_chain_id") + private String sideChainId; + + public SideChainDelegateMessage() { } + + public AddressValue getDelegatorAddress() { + return delegatorAddress; + } + + public void setDelegatorAddress(AddressValue delegatorAddress) { + this.delegatorAddress = delegatorAddress; + } + + public AddressValue getValidatorAddress() { + return validatorAddress; + } + + public void setValidatorAddress(AddressValue validatorAddress) { + this.validatorAddress = validatorAddress; + } + + public CoinValue getDelegation() { + return delegation; + } + + public void setDelegation(CoinValue delegation) { + this.delegation = delegation; + } + + public String getSideChainId() { + return sideChainId; + } + + public void setSideChainId(String sideChainId) { + this.sideChainId = sideChainId; + } + + @Override + public AminoSerializable newAminoMessage() { + return new SideChainDelegateMessage(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(AddressValue.class, delegatorAddress, delegatorAddress == null || delegatorAddress.isDefaultOrEmpty()) + .addField(AddressValue.class, validatorAddress, validatorAddress == null || validatorAddress.isDefaultOrEmpty()) + .addField(CoinValue.class, delegation, delegation == null) + .addField(String.class, sideChainId, StringUtils.isEmpty(sideChainId)) + .build(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + delegatorAddress = ((AddressValue) value); + break; + case 2: + validatorAddress = ((AddressValue) value); + break; + case 3: + delegation = ((CoinValue) value); + break; + case 4: + sideChainId = ((String) value); + break; + default: + break; + } + } + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainRedelegateMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainRedelegateMessage.java new file mode 100644 index 0000000..44c4e74 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainRedelegateMessage.java @@ -0,0 +1,124 @@ +package com.binance.dex.api.client.encoding.message.sidechain.transaction; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; +import com.binance.dex.api.client.encoding.message.sidechain.value.AddressValue; +import com.binance.dex.api.client.encoding.message.sidechain.value.CoinValue; +import com.binance.dex.api.client.encoding.serializer.AccAddressValueToStringSerializer; +import com.binance.dex.api.client.encoding.serializer.ValAddressValueToStringSerializer; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import org.apache.commons.lang3.StringUtils; + +import java.util.ArrayList; + +/** + * @author Fitz.Lu + **/ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class SideChainRedelegateMessage implements BinanceDexTransactionMessage, AminoSerializable { + + @JsonProperty(value = "delegator_addr") + @JsonSerialize(using = AccAddressValueToStringSerializer.class) + private AddressValue delegatorAddress; + + @JsonProperty(value = "validator_src_addr") + @JsonSerialize(using = ValAddressValueToStringSerializer.class) + private AddressValue srcValidatorAddress; + + @JsonProperty(value = "validator_dst_addr") + @JsonSerialize(using = ValAddressValueToStringSerializer.class) + private AddressValue dstValidatorAddress; + + @JsonProperty(value = "amount") + private CoinValue amount; + + @JsonProperty(value = "side_chain_id") + private String sideChainId; + + public SideChainRedelegateMessage() { + } + + @Override + public AminoSerializable newAminoMessage() { + return new SideChainRedelegateMessage(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(AddressValue.class, delegatorAddress, delegatorAddress == null || delegatorAddress.isDefaultOrEmpty()) + .addField(AddressValue.class, srcValidatorAddress, srcValidatorAddress == null || srcValidatorAddress.isDefaultOrEmpty()) + .addField(AddressValue.class, dstValidatorAddress, dstValidatorAddress == null || dstValidatorAddress.isDefaultOrEmpty()) + .addField(CoinValue.class, amount, amount == null) + .addField(String.class, sideChainId, StringUtils.isEmpty(sideChainId)) + .build(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + delegatorAddress = ((AddressValue) value); + break; + case 2: + srcValidatorAddress = ((AddressValue) value); + break; + case 3: + dstValidatorAddress = ((AddressValue) value); + break; + case 4: + amount = ((CoinValue) value); + break; + case 5: + sideChainId = ((String) value); + break; + default: + break; + } + } + + public AddressValue getDelegatorAddress() { + return delegatorAddress; + } + + public void setDelegatorAddress(AddressValue delegatorAddress) { + this.delegatorAddress = delegatorAddress; + } + + public AddressValue getSrcValidatorAddress() { + return srcValidatorAddress; + } + + public void setSrcValidatorAddress(AddressValue srcValidatorAddress) { + this.srcValidatorAddress = srcValidatorAddress; + } + + public AddressValue getDstValidatorAddress() { + return dstValidatorAddress; + } + + public void setDstValidatorAddress(AddressValue dstValidatorAddress) { + this.dstValidatorAddress = dstValidatorAddress; + } + + public CoinValue getAmount() { + return amount; + } + + public void setAmount(CoinValue amount) { + this.amount = amount; + } + + public String getSideChainId() { + return sideChainId; + } + + public void setSideChainId(String sideChainId) { + this.sideChainId = sideChainId; + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainUndelegateMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainUndelegateMessage.java new file mode 100644 index 0000000..f2390f9 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainUndelegateMessage.java @@ -0,0 +1,109 @@ +package com.binance.dex.api.client.encoding.message.sidechain.transaction; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; +import com.binance.dex.api.client.encoding.message.sidechain.value.AddressValue; +import com.binance.dex.api.client.encoding.message.sidechain.value.CoinValue; +import com.binance.dex.api.client.encoding.serializer.AccAddressValueToStringSerializer; +import com.binance.dex.api.client.encoding.serializer.ValAddressValueToStringSerializer; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import org.apache.commons.lang3.StringUtils; + +import java.util.ArrayList; + +/** + * @author Fitz.Lu + **/ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class SideChainUndelegateMessage implements BinanceDexTransactionMessage, AminoSerializable { + + @JsonProperty(value = "delegator_addr") + @JsonSerialize(using = AccAddressValueToStringSerializer.class) + private AddressValue delegatorAddress; + + @JsonProperty(value = "validator_addr") + @JsonSerialize(using = ValAddressValueToStringSerializer.class) + private AddressValue validatorAddress; + + @JsonProperty(value = "amount") + private CoinValue amount; + + @JsonProperty(value = "side_chain_id") + private String sideChainId; + + public SideChainUndelegateMessage() { + } + + + @Override + public AminoSerializable newAminoMessage() { + return new SideChainUndelegateMessage(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(AddressValue.class, delegatorAddress, delegatorAddress == null || delegatorAddress.isDefaultOrEmpty()) + .addField(AddressValue.class, validatorAddress, validatorAddress == null || validatorAddress.isDefaultOrEmpty()) + .addField(CoinValue.class, amount, amount == null) + .addField(String.class, sideChainId, StringUtils.isEmpty(sideChainId)) + .build(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + delegatorAddress = ((AddressValue) value); + break; + case 2: + validatorAddress = ((AddressValue) value); + break; + case 3: + amount = ((CoinValue) value); + break; + case 4: + sideChainId = ((String) value); + break; + default: + break; + } + } + + public AddressValue getDelegatorAddress() { + return delegatorAddress; + } + + public void setDelegatorAddress(AddressValue delegatorAddress) { + this.delegatorAddress = delegatorAddress; + } + + public AddressValue getValidatorAddress() { + return validatorAddress; + } + + public void setValidatorAddress(AddressValue validatorAddress) { + this.validatorAddress = validatorAddress; + } + + public CoinValue getAmount() { + return amount; + } + + public void setAmount(CoinValue amount) { + this.amount = amount; + } + + public String getSideChainId() { + return sideChainId; + } + + public void setSideChainId(String sideChainId) { + this.sideChainId = sideChainId; + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/AddressValue.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/AddressValue.java new file mode 100644 index 0000000..79999c3 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/AddressValue.java @@ -0,0 +1,77 @@ +package com.binance.dex.api.client.encoding.message.sidechain.value; + +import com.binance.dex.api.client.encoding.Crypto; +import com.binance.dex.api.client.encoding.amino.AminoCustomSerialized; +import com.binance.dex.api.client.encoding.amino.WireType; +import com.google.protobuf.CodedInputStream; +import com.google.protobuf.CodedOutputStream; +import org.apache.commons.lang3.StringUtils; + +import java.io.IOException; + +/** + * @author Fitz.Lu + **/ +public class AddressValue implements AminoCustomSerialized { + + private String address; + + public static AddressValue from(String value){ + return new AddressValue(value); + } + + public AddressValue() { + } + + public AddressValue(String address) { + this.address = address; + } + + public String getAddress() { + return address; + } + + public void setAddress(String address) { + this.address = address; + } + + @Override + public AminoCustomSerialized newAminoSerInstance() { + return new AddressValue(); + } + + @Override + public boolean isDefaultOrEmpty() { + return StringUtils.isEmpty(address); + } + + @Override + public int getWireType() { + return WireType.LENGTH_DELIMITED; + } + + @Override + public void encode(CodedOutputStream outputStream) throws IOException { + outputStream.writeByteArrayNoTag(getValueBytes()); + } + + @Override + public void decode(CodedInputStream inputStream) throws IOException { + byte[] bytes = inputStream.readByteArray(); +// address = Bech32.encode("bnb", bytes); + } + + @Override + public int getSerializedSize() { + if (StringUtils.isEmpty(address)) { + return 0; + }else{ + return CodedOutputStream.computeByteArraySizeNoTag(getValueBytes()); + } + } + + private byte[] getValueBytes(){ + return Crypto.decodeAddress(address); + } + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/CoinValue.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/CoinValue.java new file mode 100644 index 0000000..feb4174 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/CoinValue.java @@ -0,0 +1,86 @@ +package com.binance.dex.api.client.encoding.message.sidechain.value; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.Token; +import com.binance.dex.api.client.encoding.serializer.LongToStringSerializer; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import org.apache.commons.lang3.StringUtils; + +import java.util.ArrayList; + +/** + * @author Fitz.Lu + **/ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class CoinValue implements AminoSerializable { + + @JsonProperty(value = "denom") + private String denom; + + @JsonProperty(value = "amount") + @JsonSerialize(using = LongToStringSerializer.class) + private long amount; + + public CoinValue() { + } + + public CoinValue(String denom, Long amount) { + this.denom = denom; + this.amount = amount; + } + + public Token toToken(){ + Token token = new Token(); + token.setDenom(denom); + token.setAmount(amount); + return token; + } + + public String getDenom() { + return denom; + } + + public void setDenom(String denom) { + this.denom = denom; + } + + public long getAmount() { + return amount; + } + + public void setAmount(long amount) { + this.amount = amount; + } + + @Override + public AminoSerializable newAminoMessage() { + return new CoinValue(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(String.class, denom, StringUtils.isEmpty(denom)) + .addField(Long.class, amount, amount == 0) + .build(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + denom = ((String) value); + break; + case 2: + amount = ((long) value); + break; + default: + break; + } + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/CommissionMsgValue.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/CommissionMsgValue.java new file mode 100644 index 0000000..ddeeac1 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/CommissionMsgValue.java @@ -0,0 +1,89 @@ +package com.binance.dex.api.client.encoding.message.sidechain.value; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.serializer.DecToStringSerializer; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; + +import java.util.ArrayList; + +/** + * @author Fitz.Lu + **/ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class CommissionMsgValue implements AminoSerializable { + + @JsonProperty(value = "rate") + @JsonSerialize(using = DecToStringSerializer.class) + private Dec rate = new Dec(); + + @JsonProperty(value = "max_rate") + @JsonSerialize(using = DecToStringSerializer.class) + private Dec maxRate = new Dec(); + + @JsonProperty(value = "max_change_rate") + @JsonSerialize(using = DecToStringSerializer.class) + private Dec maxChangeRate = new Dec(); + + public CommissionMsgValue() { + } + + public Dec getRate() { + return rate; + } + + public void setRate(Dec rate) { + this.rate = rate; + } + + public Dec getMaxRate() { + return maxRate; + } + + public void setMaxRate(Dec maxRate) { + this.maxRate = maxRate; + } + + public Dec getMaxChangeRate() { + return maxChangeRate; + } + + public void setMaxChangeRate(Dec maxChangeRate) { + this.maxChangeRate = maxChangeRate; + } + + @Override + public AminoSerializable newAminoMessage() { + return new CommissionMsgValue(); + } + + @Override + public ArrayList> IterateFields() { + ArrayList> fields = new ArrayList<>(); + fields.add(new AminoField(Dec.class, rate, rate == null || rate.isDefaultOrEmpty())); + fields.add(new AminoField(Dec.class, maxRate, rate == null || rate.isDefaultOrEmpty())); + fields.add(new AminoField(Dec.class, maxChangeRate, rate == null || rate.isDefaultOrEmpty())); + return fields; + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + rate = ((Dec) value); + break; + case 2: + maxRate = ((Dec) value); + break; + case 3: + maxChangeRate = ((Dec) value); + break; + default: + break; + } + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/CommissionValue.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/CommissionValue.java new file mode 100644 index 0000000..6c4eb72 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/CommissionValue.java @@ -0,0 +1,108 @@ +package com.binance.dex.api.client.encoding.message.sidechain.value; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; + +import java.util.ArrayList; + +/** + * @author Fitz.Lu + **/ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class CommissionValue implements BinanceDexTransactionMessage, AminoSerializable { + + @JsonProperty(value = "rate") + private long rate; + + @JsonProperty(value = "max_rate") + private long maxRate; + + @JsonProperty(value = "max_change_rate") + private long maxChangeRate; + + @JsonProperty(value = "update_time") + private TimestampValue updateTime; + + public long getRate() { + return rate; + } + + public void setRate(long rate) { + this.rate = rate; + } + + public long getMaxRate() { + return maxRate; + } + + public void setMaxRate(long maxRate) { + this.maxRate = maxRate; + } + + public long getMaxChangeRate() { + return maxChangeRate; + } + + public void setMaxChangeRate(long maxChangeRate) { + this.maxChangeRate = maxChangeRate; + } + + public TimestampValue getUpdateTime() { + return updateTime; + } + + public void setUpdateTime(TimestampValue updateTime) { + this.updateTime = updateTime; + } + + @Override + public String toString() { + return "Commission{" + + "rate=" + rate + + ", maxRate=" + maxRate + + ", maxChangeRate=" + maxChangeRate + + ", updateTime=" + updateTime + + '}'; + } + + + @Override + public AminoSerializable newAminoMessage() { + return new CommissionValue(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(Long.class, rate, rate == 0) + .addField(Long.class, maxRate, maxRate == 0) + .addField(Long.class, maxChangeRate, maxChangeRate == 0) + .addField(TimestampValue.class, updateTime, false) + .build(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + rate = ((Long) value); + break; + case 2: + maxRate = ((Long) value); + break; + case 3: + maxChangeRate = ((Long) value); + break; + case 4: + updateTime = ((TimestampValue) value); + break; + default: + break; + } + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/Dec.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/Dec.java new file mode 100644 index 0000000..200c8f3 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/Dec.java @@ -0,0 +1,60 @@ +package com.binance.dex.api.client.encoding.message.sidechain.value; + +import com.binance.dex.api.client.encoding.amino.AminoCustomSerialized; +import com.binance.dex.api.client.encoding.amino.WireType; +import com.google.protobuf.CodedInputStream; +import com.google.protobuf.CodedOutputStream; + +import java.io.IOException; + +/** + * @author Fitz.Lu + **/ +public class Dec implements AminoCustomSerialized { + + private long value; + + public long getValue() { + return value; + } + + public void setValue(long value) { + this.value = value; + } + + public static Dec newInstance(long v){ + Dec dec = new Dec(); + dec.setValue(v); + return dec; + } + + @Override + public AminoCustomSerialized newAminoSerInstance() { + return new Dec(); + } + + @Override + public boolean isDefaultOrEmpty() { + return value == 0L; + } + + @Override + public int getWireType() { + return WireType.LENGTH_DELIMITED; + } + + @Override + public void encode(CodedOutputStream outputStream) throws IOException { + outputStream.writeInt64NoTag(value); + } + + @Override + public void decode(CodedInputStream inputStream) throws IOException { + value = inputStream.readInt64(); + } + + @Override + public int getSerializedSize() { + return CodedOutputStream.computeInt64SizeNoTag(value); + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/DelegationValue.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/DelegationValue.java new file mode 100644 index 0000000..ec607c8 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/DelegationValue.java @@ -0,0 +1,62 @@ +package com.binance.dex.api.client.encoding.message.sidechain.value; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; + +import java.util.ArrayList; + +/** + * @author Fitz.Lu + **/ +public class DelegationValue implements AminoSerializable { + + private Dec shares = new Dec(); + + private long height; + + public DelegationValue() { + } + + public Dec getShares() { + return shares; + } + + public void setShares(Dec shares) { + this.shares = shares; + } + + public long getHeight() { + return height; + } + + public void setHeight(long height) { + this.height = height; + } + + @Override + public AminoSerializable newAminoMessage() { + return new DelegationValue(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(Dec.class, shares, shares == null || shares.isDefaultOrEmpty()) + .addField(Long.class, height, height == 0) + .build(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + shares = ((Dec) value); + break; + case 2: + height = ((Long) value); + break; + default: + break; + } + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/DescriptionValue.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/DescriptionValue.java new file mode 100644 index 0000000..425674a --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/DescriptionValue.java @@ -0,0 +1,118 @@ +package com.binance.dex.api.client.encoding.message.sidechain.value; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import org.apache.commons.lang3.StringUtils; + +import java.util.ArrayList; + +/** + * @author Fitz.Lu + **/ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class DescriptionValue implements BinanceDexTransactionMessage, AminoSerializable { + + @JsonProperty(value = "moniker") + private String moniker = ""; + + @JsonProperty(value = "identity") + private String identity = ""; + + @JsonProperty(value = "website") + private String website = ""; + + @JsonProperty(value = "details") + private String details = ""; + + public DescriptionValue() { + } + + public DescriptionValue(String moniker, String identity, String website, String details) { + this.moniker = moniker; + this.identity = identity; + this.website = website; + this.details = details; + } + + public String getMoniker() { + return moniker; + } + + public void setMoniker(String moniker) { + this.moniker = moniker; + } + + public String getIdentity() { + return identity; + } + + public void setIdentity(String identity) { + this.identity = identity; + } + + public String getWebsite() { + return website; + } + + public void setWebsite(String website) { + this.website = website; + } + + public String getDetails() { + return details; + } + + public void setDetails(String details) { + this.details = details; + } + + @Override + public String toString() { + return "Description{" + + "moniker='" + moniker + '\'' + + ", identity='" + identity + '\'' + + ", website='" + website + '\'' + + ", details='" + details + '\'' + + '}'; + } + + @Override + public AminoSerializable newAminoMessage() { + return new DescriptionValue(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + moniker = ((String) value); + break; + case 2: + identity = ((String) value); + break; + case 3: + website = ((String) value); + break; + case 4: + details = ((String) value); + break; + default: + break; + } + } + + @Override + public ArrayList> IterateFields() { + ArrayList> fields = new ArrayList<>(); + fields.add(new AminoField<>(String.class, moniker, StringUtils.isEmpty(moniker))); + fields.add(new AminoField<>(String.class, identity, StringUtils.isEmpty(identity))); + fields.add(new AminoField<>(String.class, website, StringUtils.isEmpty(website))); + fields.add(new AminoField<>(String.class, details, StringUtils.isEmpty(details))); + return fields; + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/RedelegationValue.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/RedelegationValue.java new file mode 100644 index 0000000..b3a3240 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/RedelegationValue.java @@ -0,0 +1,118 @@ +package com.binance.dex.api.client.encoding.message.sidechain.value; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; + +import java.util.ArrayList; + +/** + * @author Fitz.Lu + **/ +public class RedelegationValue implements AminoSerializable { + + private long creationHeight; + + private TimestampValue minTime = new TimestampValue(); + + private CoinValue initialBalance = new CoinValue(); + + private CoinValue balance = new CoinValue(); + + private Dec sharesSrc = new Dec(); + + private Dec sharesDst = new Dec(); + + public RedelegationValue() { + } + + public long getCreationHeight() { + return creationHeight; + } + + public void setCreationHeight(long creationHeight) { + this.creationHeight = creationHeight; + } + + public TimestampValue getMinTime() { + return minTime; + } + + public void setMinTime(TimestampValue minTime) { + this.minTime = minTime; + } + + public CoinValue getInitialBalance() { + return initialBalance; + } + + public void setInitialBalance(CoinValue initialBalance) { + this.initialBalance = initialBalance; + } + + public CoinValue getBalance() { + return balance; + } + + public void setBalance(CoinValue balance) { + this.balance = balance; + } + + public Dec getSharesSrc() { + return sharesSrc; + } + + public void setSharesSrc(Dec sharesSrc) { + this.sharesSrc = sharesSrc; + } + + public Dec getSharesDst() { + return sharesDst; + } + + public void setSharesDst(Dec sharesDst) { + this.sharesDst = sharesDst; + } + + @Override + public AminoSerializable newAminoMessage() { + return new RedelegationValue(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(Long.class, creationHeight, creationHeight == 0) + .addField(TimestampValue.class, minTime, minTime == null) + .addField(CoinValue.class, initialBalance, initialBalance == null) + .addField(CoinValue.class, balance, balance == null) + .addField(Dec.class, sharesSrc, sharesSrc == null) + .addField(Dec.class, sharesDst, sharesDst == null) + .build(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + creationHeight = ((long) value); + break; + case 2: + minTime = ((TimestampValue) value); + break; + case 3: + initialBalance = ((CoinValue) value); + break; + case 4: + balance = ((CoinValue) value); + break; + case 5: + sharesSrc = ((Dec) value); + break; + case 6: + sharesDst = ((Dec) value); + break; + default: + break; + } + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/TimestampValue.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/TimestampValue.java new file mode 100644 index 0000000..7f3581f --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/TimestampValue.java @@ -0,0 +1,66 @@ +package com.binance.dex.api.client.encoding.message.sidechain.value; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; + +import java.util.ArrayList; + +/** + * @author Fitz.Lu + **/ +public class TimestampValue implements AminoSerializable { + + private long seconds; + + private int nano; + + public TimestampValue() { + } + + public long getSeconds() { + return seconds; + } + + public void setSeconds(long seconds) { + this.seconds = seconds; + } + + public int getNano() { + return nano; + } + + public void setNano(int nano) { + this.nano = nano; + } + + public long getTimeInMilliseconds(){ + return seconds * 1000; + } + + @Override + public AminoSerializable newAminoMessage() { + return new TimestampValue(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(Long.class, seconds, false) + .addField(Integer.class, nano, false) + .build(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + seconds = ((Long) value); + break; + case 2: + nano = ((Integer) value); + break; + default: + break; + } + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/TokenMessageValue.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/TokenMessageValue.java new file mode 100644 index 0000000..78a26d6 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/TokenMessageValue.java @@ -0,0 +1,73 @@ +package com.binance.dex.api.client.encoding.message.sidechain.value; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.serializer.LongToStringSerializer; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import org.apache.commons.lang3.StringUtils; + +import java.util.ArrayList; + +/** + * @author Fitz.Lu + **/ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class TokenMessageValue implements AminoSerializable { + + @JsonProperty(value = "denom") + private String denom; + + @JsonProperty(value = "amount") + @JsonSerialize(using = LongToStringSerializer.class) + private long amount; + + public TokenMessageValue() { } + + public String getDenom() { + return denom; + } + + public void setDenom(String denom) { + this.denom = denom; + } + + public long getAmount() { + return amount; + } + + public void setAmount(long amount) { + this.amount = amount; + } + + @Override + public AminoSerializable newAminoMessage() { + return new TokenMessageValue(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + denom = ((String) value); + break; + case 2: + amount = ((long) value); + break; + default: + break; + } + } + + @Override + public ArrayList> IterateFields() { + ArrayList> fields = new ArrayList<>(); + fields.add(new AminoField<>(String.class, denom, StringUtils.isEmpty(denom))); + fields.add(new AminoField<>(Long.class, amount, amount == 0)); + return fields; + } + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/UnBondingValue.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/UnBondingValue.java new file mode 100644 index 0000000..f04f485 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/UnBondingValue.java @@ -0,0 +1,90 @@ +package com.binance.dex.api.client.encoding.message.sidechain.value; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; + +import java.util.ArrayList; + +/** + * @author Fitz.Lu + **/ +public class UnBondingValue implements AminoSerializable { + + private long creationHeight; + + private TimestampValue minTime = new TimestampValue(); + + private CoinValue initialBalance = new CoinValue(); + + private CoinValue balance = new CoinValue(); + + public UnBondingValue() { + } + + public long getCreationHeight() { + return creationHeight; + } + + public void setCreationHeight(long creationHeight) { + this.creationHeight = creationHeight; + } + + public TimestampValue getMinTime() { + return minTime; + } + + public void setMinTime(TimestampValue minTime) { + this.minTime = minTime; + } + + public CoinValue getInitialBalance() { + return initialBalance; + } + + public void setInitialBalance(CoinValue initialBalance) { + this.initialBalance = initialBalance; + } + + public CoinValue getBalance() { + return balance; + } + + public void setBalance(CoinValue balance) { + this.balance = balance; + } + + @Override + public AminoSerializable newAminoMessage() { + return new UnBondingValue(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(Long.class, creationHeight, creationHeight == 0) + .addField(TimestampValue.class, minTime, minTime == null) + .addField(CoinValue.class, initialBalance, initialBalance == null) + .addField(CoinValue.class, balance, balance == null) + .build(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + creationHeight = ((Long) value); + break; + case 2: + minTime = ((TimestampValue) value); + break; + case 3: + initialBalance = ((CoinValue) value); + break; + case 4: + balance = ((CoinValue) value); + break; + default: + break; + } + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/serializer/AccAddressValueToStringSerializer.java b/src/main/java/com/binance/dex/api/client/encoding/serializer/AccAddressValueToStringSerializer.java new file mode 100644 index 0000000..5899a6a --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/serializer/AccAddressValueToStringSerializer.java @@ -0,0 +1,21 @@ +package com.binance.dex.api.client.encoding.serializer; + +import com.binance.dex.api.client.encoding.message.sidechain.value.AddressValue; +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.databind.JsonSerializer; +import com.fasterxml.jackson.databind.SerializerProvider; + +import java.io.IOException; + +/** + * @author Fitz.Lu + **/ +public class AccAddressValueToStringSerializer extends JsonSerializer { + + @Override + public void serialize(AddressValue addressValue, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { + if (addressValue != null && addressValue.getAddress() != null){ + jsonGenerator.writeString(addressValue.getAddress()); + } + } +} \ No newline at end of file diff --git a/src/main/java/com/binance/dex/api/client/encoding/serializer/ByteArrayToStringSerializer.java b/src/main/java/com/binance/dex/api/client/encoding/serializer/ByteArrayToStringSerializer.java new file mode 100644 index 0000000..f693298 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/serializer/ByteArrayToStringSerializer.java @@ -0,0 +1,21 @@ +package com.binance.dex.api.client.encoding.serializer; + +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.databind.JsonSerializer; +import com.fasterxml.jackson.databind.SerializerProvider; + +import java.io.IOException; + +/** + * @author Fitz.Lu + **/ +public class ByteArrayToStringSerializer extends JsonSerializer { + + @Override + public void serialize(byte[] bytes, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { + if(bytes != null){ + jsonGenerator.writeString(new String(bytes)); + } + } + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/serializer/DecToStringSerializer.java b/src/main/java/com/binance/dex/api/client/encoding/serializer/DecToStringSerializer.java new file mode 100644 index 0000000..6f489c9 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/serializer/DecToStringSerializer.java @@ -0,0 +1,20 @@ +package com.binance.dex.api.client.encoding.serializer; + +import com.binance.dex.api.client.encoding.message.sidechain.value.Dec; +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.databind.JsonSerializer; +import com.fasterxml.jackson.databind.SerializerProvider; + +import java.io.IOException; + +/** + * @author Fitz.Lu + **/ +public class DecToStringSerializer extends JsonSerializer { + @Override + public void serialize(Dec dec, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { + if (dec != null) { + jsonGenerator.writeString(String.valueOf(dec.getValue())); + } + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/serializer/LongToStringSerializer.java b/src/main/java/com/binance/dex/api/client/encoding/serializer/LongToStringSerializer.java new file mode 100644 index 0000000..a7b4d3a --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/serializer/LongToStringSerializer.java @@ -0,0 +1,17 @@ +package com.binance.dex.api.client.encoding.serializer; + +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.databind.JsonSerializer; +import com.fasterxml.jackson.databind.SerializerProvider; + +import java.io.IOException; + +/** + * @author Fitz.Lu + **/ +public class LongToStringSerializer extends JsonSerializer { + @Override + public void serialize(Long aLong, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { + jsonGenerator.writeString(String.valueOf(aLong)); + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/serializer/ValAddressValueToStringSerializer.java b/src/main/java/com/binance/dex/api/client/encoding/serializer/ValAddressValueToStringSerializer.java new file mode 100644 index 0000000..810ed37 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/serializer/ValAddressValueToStringSerializer.java @@ -0,0 +1,23 @@ +package com.binance.dex.api.client.encoding.serializer; + +import com.binance.dex.api.client.encoding.Bech32; +import com.binance.dex.api.client.encoding.message.sidechain.value.AddressValue; +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.databind.JsonSerializer; +import com.fasterxml.jackson.databind.SerializerProvider; + +import java.io.IOException; + +/** + * @author Fitz.Lu + **/ +public class ValAddressValueToStringSerializer extends JsonSerializer { + + @Override + public void serialize(AddressValue addressValue, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { + if (addressValue != null && addressValue.getAddress() != null){ + Bech32.Bech32Data bech32Data = Bech32.decode(addressValue.getAddress()); + jsonGenerator.writeString(Bech32.encode("bva", bech32Data.getData())); + } + } +} diff --git a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java index e964d5b..32356bf 100644 --- a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java +++ b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java @@ -2,10 +2,17 @@ import com.binance.dex.api.client.*; import com.binance.dex.api.client.domain.*; +import com.binance.dex.api.client.domain.sidechain.*; import com.binance.dex.api.client.domain.StakeValidator; +import com.binance.dex.api.client.domain.sidechain.CreateSideChainValidator; +import com.binance.dex.api.client.domain.sidechain.EditSideChainValidator; import com.binance.dex.api.client.domain.broadcast.Transaction; import com.binance.dex.api.client.domain.broadcast.*; import com.binance.dex.api.client.domain.jsonrpc.*; +import com.binance.dex.api.client.domain.sidechain.SideChainDelegate; +import com.binance.dex.api.client.domain.sidechain.SideChainRedelegate; +import com.binance.dex.api.client.domain.sidechain.SideChainUnBond; +import com.binance.dex.api.client.domain.sidechain.SideChainValidator; import com.binance.dex.api.client.encoding.Crypto; import com.binance.dex.api.client.encoding.EncodeUtils; import com.binance.dex.api.client.encoding.message.TransactionRequestAssembler; @@ -28,7 +35,7 @@ public class BinanceDexApiNodeClientImpl implements BinanceDexApiNodeClient { - private BinanceDexNodeApi binanceDexNodeApi; + protected BinanceDexNodeApi binanceDexNodeApi; private String hrp; @@ -42,11 +49,15 @@ public class BinanceDexApiNodeClientImpl implements BinanceDexApiNodeClient { private final static int TX_SEARCH_PERPAGE = 10000; + private final BinanceDexApiNodeClientImplSideChainQueryDelegate sideChainQueryDelegate; + public BinanceDexApiNodeClientImpl(String nodeUrl, String hrp) { this.binanceDexNodeApi = BinanceDexApiClientGenerator.createService(BinanceDexNodeApi.class, nodeUrl); this.hrp = hrp; transactionConverter = new TransactionConverter(hrp); feeConverter = new FeeConverter(); + + sideChainQueryDelegate = new BinanceDexApiNodeClientImplSideChainQueryDelegate(binanceDexNodeApi); } @Override @@ -341,6 +352,116 @@ public List refundHtlt(String swapId, Wallet wallet, Transa } } + @Override + public List createSideChainValidator(CreateSideChainValidator createSideChainValidator, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + synchronized (wallet) { + wallet.ensureWalletIsReady(this); + TransactionRequestAssembler assembler = new TransactionRequestAssembler(wallet, options); + String requestPayload = "0x" + assembler.buildCreateSideChainValidatorPayload(createSideChainValidator); + if (sync) { + return syncBroadcast(requestPayload, wallet); + } else { + return asyncBroadcast(requestPayload, wallet); + } + } + } + + @Override + public List editSideChainValidator(EditSideChainValidator editSideChainValidator, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + synchronized (wallet) { + wallet.ensureWalletIsReady(this); + TransactionRequestAssembler assembler = new TransactionRequestAssembler(wallet, options); + String requestPayload = "0x" + assembler.buildEditSideChainValidatorPayload(editSideChainValidator); + if (sync) { + return syncBroadcast(requestPayload, wallet); + } else { + return asyncBroadcast(requestPayload, wallet); + } + } + } + + @Override + public List sideChainDelegate(SideChainDelegate sideChainDelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + synchronized (wallet) { + wallet.ensureWalletIsReady(this); + TransactionRequestAssembler assembler = new TransactionRequestAssembler(wallet, options); + String requestPayload = "0x" + assembler.buildSideChainDelegatePayload(sideChainDelegate); + if (sync) { + return syncBroadcast(requestPayload, wallet); + } else { + return asyncBroadcast(requestPayload, wallet); + } + } + } + + @Override + public List sideChainRedelagate(SideChainRedelegate sideChainRedelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + synchronized (wallet) { + wallet.ensureWalletIsReady(this); + TransactionRequestAssembler assembler = new TransactionRequestAssembler(wallet, options); + String requestPayload = "0x" + assembler.buildSideChainRedelegatePayload(sideChainRedelegate); + if (sync) { + return syncBroadcast(requestPayload, wallet); + } else { + return asyncBroadcast(requestPayload, wallet); + } + } + } + + @Override + public List sideChainUnbond(SideChainUnBond sideChainUndelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + synchronized (wallet) { + wallet.ensureWalletIsReady(this); + TransactionRequestAssembler assembler = new TransactionRequestAssembler(wallet, options); + String requestPayload = "0x" + assembler.buildSideChainUndelegatePayload(sideChainUndelegate); + if (sync) { + return syncBroadcast(requestPayload, wallet); + } else { + return asyncBroadcast(requestPayload, wallet); + } + } + } + + @Override + public SideChainValidator getSideChainValidator(String sideChainId, byte[] validatorAddress) throws IOException { + return sideChainQueryDelegate.querySideChainValidator(sideChainId, validatorAddress); + } + + @Override + public List getSideChainTopValidators(String sideChainId, int top) throws IOException { + return sideChainQueryDelegate.querySideChainTopValidators(sideChainId, top); + } + + @Override + public SideChainDelegation getSideChainDelegation(String sideChainId, byte[] delegatorAddress, byte[] validatorAddress) throws IOException { + return sideChainQueryDelegate.querySideChainDelegation(sideChainId, delegatorAddress, validatorAddress); + } + + @Override + public List getSideChainDelegations(String sideChainId, byte[] delegatorAddress) throws IOException { + return sideChainQueryDelegate.querySideChainDelegations(sideChainId, delegatorAddress); + } + + @Override + public SideChainRedelegation getSideChainRedelegation(String sideChainId, byte[] delegatorAddress, byte[] srcValidatorAddress, byte[] dstValidatorAddress) throws IOException { + return sideChainQueryDelegate.querySideChainRedelegation(sideChainId, delegatorAddress, srcValidatorAddress, dstValidatorAddress); + } + + @Override + public List getSideChainRedelegations(String sideChainId, byte[] delegatorAddress) throws IOException { + return sideChainQueryDelegate.querySideChainRedelegations(sideChainId, delegatorAddress); + } + + @Override + public SideChainUnBondingDelegation getSideChainUnBondingDelegation(String sideChainId, byte[] delegatorAddress, byte[] validatorAddress) throws IOException { + return sideChainQueryDelegate.querySideChainUnBondingDelegation(sideChainId, delegatorAddress, validatorAddress); + } + + @Override + public List getSideChainUnBondingDelegations(String sideChainId, byte[] delegatorAddress) throws IOException { + return sideChainQueryDelegate.querySideChainUnBondingDelegations(sideChainId, delegatorAddress); + } + @Override public List broadcast(String payload, boolean sync) { payload = "0x" + payload; diff --git a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImplSideChainQueryDelegate.java b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImplSideChainQueryDelegate.java new file mode 100644 index 0000000..1e45fba --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImplSideChainQueryDelegate.java @@ -0,0 +1,449 @@ +package com.binance.dex.api.client.impl; + +import com.binance.dex.api.client.*; +import com.binance.dex.api.client.domain.jsonrpc.ABCIQueryResult; +import com.binance.dex.api.client.domain.jsonrpc.JsonRpcResponse; +import com.binance.dex.api.client.domain.sidechain.*; +import com.binance.dex.api.client.encoding.ByteUtil; +import com.binance.dex.api.client.encoding.EncodeUtils; +import com.binance.dex.api.client.encoding.amino.Amino; +import com.binance.dex.api.client.encoding.amino.WireType; +import com.binance.dex.api.client.encoding.message.sidechain.query.BechValidator; +import com.binance.dex.api.client.encoding.message.sidechain.query.QueryTopValidatorParams; +import com.binance.dex.api.client.encoding.message.sidechain.query.SideChainValidatorMessage; +import com.binance.dex.api.client.encoding.message.sidechain.value.DelegationValue; +import com.binance.dex.api.client.encoding.message.sidechain.value.RedelegationValue; +import com.binance.dex.api.client.encoding.message.sidechain.value.UnBondingValue; +import com.fasterxml.jackson.core.type.TypeReference; +import com.google.common.base.Charsets; +import com.google.protobuf.CodedInputStream; +import com.google.protobuf.InvalidProtocolBufferException; +import org.bouncycastle.util.encoders.Hex; +import types.Types; + +import java.io.IOException; +import java.nio.charset.Charset; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +/** + * @author Fitz.Lu + **/ +class BinanceDexApiNodeClientImplSideChainQueryDelegate { + + private final String stakeStoreName = "stake"; + private final String scStoreKey = "sc"; + + private static final int addressLength = 20; + + private final byte[] sideChainStorePrefixByIdKey = new byte[]{0x01}; + private final byte[] validatorsKey = new byte[]{0x21}; + private final byte[] delegationKey = new byte[]{0x31}; + private final byte[] redelegationKey = new byte[]{0x34}; + private final byte[] unBondingDelegationKey = new byte[]{0x32}; + + private final Charset defaultCharset = Charsets.UTF_8; + + private final BinanceDexNodeApi binanceDexNodeApi; + + private final Amino amino; + + BinanceDexApiNodeClientImplSideChainQueryDelegate(BinanceDexNodeApi binanceDexNodeApi) { + this.binanceDexNodeApi = binanceDexNodeApi; + this.amino = new Amino(); + } + + SideChainValidator querySideChainValidator(String sideChainId, byte[] validatorAddress) throws IOException { + byte[] storePrefix = getSideChainStorePrefixKey(sideChainId); + byte[] keyPrefix = queryStore(stakeStoreName, storePrefix); + if (keyPrefix == null) { + keyPrefix = new byte[0]; + } + byte[] key = ByteUtil.appendBytesArray(keyPrefix, getValidatorKey(validatorAddress)); + byte[] result = queryStore(stakeStoreName, key); + + if (result != null) { + SideChainValidatorMessage message = new SideChainValidatorMessage(); + amino.decodeWithLengthPrefix(result, message); + return convert(message); + }else{ + return null; + } + } + + List querySideChainTopValidators(String sideChainId, int top) throws IOException { + if (top > 50 || top < 1){ + throw new IllegalArgumentException("top must be between 1 and 50"); + } + + QueryTopValidatorParams params = new QueryTopValidatorParams(); + params.setSideChainId(sideChainId); + params.setTop(top); + byte[] data = EncodeUtils.toJsonEncodeBytes(params); + byte[] result = queryWithData("\"custom/stake/topValidators\"", data); + + String jsonStr = new String(result); + + List bechValidator = EncodeUtils.getObjectMapper().readValue(jsonStr, new TypeReference>(){}); + + List sideChainValidators = new ArrayList<>(); + + if (bechValidator != null && !bechValidator.isEmpty()){ + for (BechValidator validator : bechValidator) { + sideChainValidators.add(validator.toSideChainValidator()); + } + } + + return sideChainValidators; + } + + private SideChainValidator convert(SideChainValidatorMessage message){ + SideChainValidator sideChainValidator = new SideChainValidator(); + + sideChainValidator.setFeeAddr(message.getFeeAddr()); + sideChainValidator.setOperatorAddr(message.getOperatorAddr()); + + //TODO consPubKey use amino decode with type prefix + boolean fallBack = true; + byte[] typePrefix = ByteUtil.pick(message.getConsPubKey(), 0, 4); + if (WireType.isRegistered(typePrefix)){ + byte length = ByteUtil.pick(message.getConsPubKey(), 4, 1)[0]; + int len = Byte.toUnsignedInt(length); + if (message.getConsPubKey().length - 5 == len){ + sideChainValidator.setConsPubKey(ByteUtil.cut(message.getConsPubKey(), 5)); + fallBack = false; + } + } + if (fallBack) { + sideChainValidator.setConsPubKey(message.getConsPubKey()); + } + + sideChainValidator.setJailed(message.isJailed()); + sideChainValidator.setStatus(message.getStatus()); + sideChainValidator.setTokens(message.getTokens().getValue()); + sideChainValidator.setDelegatorShares(message.getDelegatorShares().getValue()); + + Description description = new Description(); + if (message.getDescription() != null){ + description.setMoniker(message.getDescription().getMoniker()); + description.setWebsite(message.getDescription().getWebsite()); + description.setDetails(message.getDescription().getDetails()); + description.setIdentity(message.getDescription().getIdentity()); + } + sideChainValidator.setDescription(description); + + sideChainValidator.setBondHeight(message.getBondHeight()); + sideChainValidator.setBondIntraTxCounter(message.getBondIntraTxCounter()); + sideChainValidator.setUnBondingHeight(message.getUnBondingHeight()); + sideChainValidator.setUnBondingMinTime(message.getUnBondingMinTime()); + + Commission commission = new Commission(); + if (message.getCommission() != null) { + commission.setRate(message.getCommission().getRate()); + commission.setMaxRate(message.getCommission().getMaxRate()); + commission.setMaxChangeRate(message.getCommission().getMaxChangeRate()); + } + sideChainValidator.setCommission(commission); + + sideChainValidator.setSideChainId(message.getSideChainId()); + sideChainValidator.setSideConsAddr(message.getSideConsAddr()); + sideChainValidator.setSideFeeAddr(message.getSideFeeAddr()); + + return sideChainValidator; + } + + SideChainDelegation querySideChainDelegation(String sideChainId, byte[] delegatorAddress, byte[] validatorAddress) throws IOException { + byte[] storePrefix = getSideChainStorePrefixKey(sideChainId); + byte[] delegationKey = getDelegationKey(delegatorAddress, validatorAddress); + + byte[] key = ByteUtil.appendBytesArray(storePrefix, delegationKey); + byte[] result = queryStore(stakeStoreName, key); + + if (result != null && result.length > 0){ + DelegationValue delegationValue = new DelegationValue(); + amino.decodeWithLengthPrefix(result, delegationValue); + return convert(delegationValue, delegationKey); + } + + return null; + } + + List querySideChainDelegations(String sideChainId, byte[] delegatorAddress) throws IOException { + byte[] storePrefix = getSideChainStorePrefixKey(sideChainId); + byte[] key = ByteUtil.appendBytesArray(storePrefix, getDelegationsKey(delegatorAddress)); + List kvPairs = queryStoreSubspaceKVPairs(stakeStoreName, key); + + List delegations = new ArrayList<>(); + for (common.Types.KVPair kvPair : kvPairs) { + DelegationValue value = new DelegationValue(); + amino.decodeWithLengthPrefix(kvPair.getValue().toByteArray(), value); + delegations.add(convert(value, Arrays.copyOfRange(kvPair.getKey().toByteArray(), storePrefix.length, kvPair.getKey().toByteArray().length))); + } + + return delegations; + } + + private SideChainDelegation convert(DelegationValue delegationValue, byte[] key){ + if (key.length - 1 != addressLength * 2){ + throw new IllegalArgumentException("unexpected address length for this (address, validator) pair"); + } + byte[] delAddress = new byte[addressLength]; + byte[] valAddress = new byte[addressLength]; + + System.arraycopy(key, 1, delAddress, 0, addressLength); + System.arraycopy(key, addressLength, valAddress, 0, addressLength); + + SideChainDelegation sideChainDelegation = new SideChainDelegation(); + sideChainDelegation.setDelegatorAddress(delAddress); + sideChainDelegation.setValidatorAddress(valAddress); + sideChainDelegation.setHeight(delegationValue.getHeight()); + if (delegationValue.getShares() != null) { + sideChainDelegation.setShares(delegationValue.getShares().getValue()); + } + + return sideChainDelegation; + } + + SideChainRedelegation querySideChainRedelegation(String sideChainId, byte[] delegatorAddress, byte[] srcValidatorAddress, byte[] dstValidatorAddress) throws IOException { + byte[] storePrefix = getSideChainStorePrefixKey(sideChainId); + byte[] redKey = getRedelegationKey(delegatorAddress, srcValidatorAddress, dstValidatorAddress); + byte[] key = ByteUtil.appendBytesArray(storePrefix, redKey); + byte[] result = queryStore(stakeStoreName, key); + + if (!ByteUtil.isEmpty(result)){ + RedelegationValue message = new RedelegationValue(); + amino.decodeWithLengthPrefix(result, message); + return convert(message, redKey); + } + + return null; + } + + List querySideChainRedelegations(String sideChainId, byte[] delegatorAddress) throws IOException { + byte[] storePrefix = getSideChainStorePrefixKey(sideChainId); + byte[] redsKey = getRedelegationsKey(delegatorAddress); + byte[] key = ByteUtil.appendBytesArray(storePrefix, redsKey); + List result = queryStoreSubspaceKVPairs(stakeStoreName, key); + List redelegations = new ArrayList<>(); + if (result != null && !result.isEmpty()){ + for (common.Types.KVPair kvPair : result) { + byte[] k = ByteUtil.cut(kvPair.getKey().toByteArray(), storePrefix.length); + RedelegationValue message = new RedelegationValue(); + amino.decodeWithLengthPrefix(kvPair.getValue().toByteArray(), message); + redelegations.add(convert(message, k)); + } + } + + return redelegations; + } + + private SideChainRedelegation convert(RedelegationValue value, byte[] key){ + byte[] addresses = ByteUtil.cut(key, 1); + if (addresses.length != addressLength * 3){ + throw new IllegalStateException("unexpected address length for (address, srcValidator, dstValidator)"); + } + + byte[] delAddr = ByteUtil.pick(addresses, 0, addressLength); + byte[] srcValAddr = ByteUtil.pick(addresses, addressLength, addressLength); + byte[] dstValAddr = ByteUtil.pick(addresses, addressLength * 2, addressLength); + + SideChainRedelegation redelegation = new SideChainRedelegation(); + redelegation.setDelegatorAddress(delAddr); + redelegation.setSrcValidatorAddress(srcValAddr); + redelegation.setDstValidatorAddress(dstValAddr); + + redelegation.setCreateHeight(value.getCreationHeight()); + if (value.getMinTime() != null) { + redelegation.setMinTimeInMs(value.getMinTime().getTimeInMilliseconds()); + } + if (value.getInitialBalance() != null){ + redelegation.setInitialBalance(value.getInitialBalance().toToken()); + } + if (value.getBalance() != null){ + redelegation.setBalance(value.getBalance().toToken()); + } + + if (value.getSharesSrc() != null){ + redelegation.setSrcShares(value.getSharesSrc().getValue()); + } + + if (value.getSharesDst() != null){ + redelegation.setDstShare(value.getSharesDst().getValue()); + } + + return redelegation; + } + + SideChainUnBondingDelegation querySideChainUnBondingDelegation(String sideChainId, byte[] delegatorAddress, byte[] validatorAddress) throws IOException { + byte[] storePrefix = getSideChainStorePrefixKey(sideChainId); + byte[] ubdKey = getUnBondingDelegationKey(delegatorAddress, validatorAddress); + byte[] key = ByteUtil.appendBytesArray(storePrefix, ubdKey); + byte[] result = queryStore(stakeStoreName, key); + if (!ByteUtil.isEmpty(result)) { + UnBondingValue unBondingValue = new UnBondingValue(); + amino.decodeWithLengthPrefix(result, unBondingValue); + return convert(unBondingValue, ByteUtil.cut(ubdKey, unBondingDelegationKey.length)); + }else{ + return null; + } + } + + List querySideChainUnBondingDelegations(String sideChainId, byte[] delegatorAddress) throws IOException { + byte[] storePrefix = getSideChainStorePrefixKey(sideChainId); + byte[] ubdsKey = getUnBondingDelegationsKey(delegatorAddress); + byte[] key = ByteUtil.appendBytesArray(storePrefix, ubdsKey); + List kvPairs = queryStoreSubspaceKVPairs(stakeStoreName, key); + List unBondingDelegations = new ArrayList<>(); + if (kvPairs != null && !kvPairs.isEmpty()){ + for (common.Types.KVPair kvPair : kvPairs) { + UnBondingValue unBondingValue = new UnBondingValue(); + amino.decodeWithLengthPrefix(kvPair.getValue().toByteArray(), unBondingValue); + unBondingDelegations.add(convert(unBondingValue, ByteUtil.cut(kvPair.getKey().toByteArray(), storePrefix.length + unBondingDelegationKey.length))); + } + } + + return unBondingDelegations; + } + + private SideChainUnBondingDelegation convert(UnBondingValue value, byte[] addresses){ + if (addresses.length != addressLength * 2){ + throw new IllegalStateException("unexpected address length for this (address, validator) pair"); + } + + SideChainUnBondingDelegation unBondingDelegation = new SideChainUnBondingDelegation(); + unBondingDelegation.setDelegatorAddress(ByteUtil.pick(addresses, 0, addressLength)); + unBondingDelegation.setValidatorAddress(ByteUtil.pick(addresses, addressLength, addressLength)); + unBondingDelegation.setCreateHeight(value.getCreationHeight()); + if (value.getMinTime() != null){ + unBondingDelegation.setMinTimeInMs(value.getMinTime().getTimeInMilliseconds()); + } + if (value.getInitialBalance() != null){ + unBondingDelegation.setInitialBalance(value.getInitialBalance().toToken()); + } + if (value.getBalance() != null){ + unBondingDelegation.setBalance(value.getBalance().toToken()); + } + + return unBondingDelegation; + } + + private byte[] getSideChainStorePrefixKey(String sideChainId){ + byte[] sideChainIdBytes = sideChainId.getBytes(defaultCharset); + byte[] key = ByteUtil.appendBytesArray(sideChainStorePrefixByIdKey, sideChainIdBytes); + byte[] result = queryStore(scStoreKey, key); + + if (result == null || result.length == 0){ + throw new IllegalArgumentException("Invalid sideChainId: " + sideChainId); + } + + return result; + } + + private byte[] getValidatorKey(byte[] operatorAddress){ + return ByteUtil.appendBytesArray(validatorsKey, operatorAddress); + } + + private byte[] getRedelegationKey(byte[] delAddr, byte[] srcValAddr, byte[] dstValAddr){ + int length = 1 + addressLength * 3; + byte[] key = new byte[length]; + + byte[] redsKey = getRedelegationsKey(delAddr); + System.arraycopy(redsKey, 0, key, 0, redsKey.length); + System.arraycopy(srcValAddr, 0, key, redsKey.length, srcValAddr.length); + System.arraycopy(dstValAddr, 0, key, redsKey.length + srcValAddr.length, dstValAddr.length); + return key; + } + + private byte[] getDelegationKey(byte[] delegateAddress, byte[] validatorAddress){ + return ByteUtil.appendBytesArray(getDelegationsKey(delegateAddress), validatorAddress); + } + + private byte[] getDelegationsKey(byte[] delegateAddress){ + return ByteUtil.appendBytesArray(delegationKey, delegateAddress); + } + + private byte[] getRedelegationsKey(byte[] delAddr){ + return ByteUtil.appendBytesArray(redelegationKey, delAddr); + } + + byte[] getUnBondingDelegationKey(byte[] delegatorAddress, byte[] validatorAddress){ + return ByteUtil.appendBytesArray(getUnBondingDelegationsKey(delegatorAddress), validatorAddress); + } + + byte[] getUnBondingDelegationsKey(byte[] delegatorAddress){ + return ByteUtil.appendBytesArray(unBondingDelegationKey, delegatorAddress); + } + + private byte[] queryWithData(String path, byte[] data){ + String d = "0x" + Hex.toHexString(data); + JsonRpcResponse rpcResponse = BinanceDexApiClientGenerator.executeSync(binanceDexNodeApi.abciQuery(path, d)); + checkABCIResponse(rpcResponse); + + return rpcResponse.getResult().getResponse().getValue(); + } + + private byte[] queryStore(String storeName, byte[] key){ + String keyHex = "0x" + Hex.toHexString(key); + String path = String.format("\"/store/%s/%s\"", storeName, "key"); + JsonRpcResponse rpcResponse = BinanceDexApiClientGenerator.executeSync(binanceDexNodeApi.abciQuery(path, keyHex)); + checkABCIResponse(rpcResponse); + + return rpcResponse.getResult().getResponse().getValue(); + } + + private byte[] queryStoreSubspace(String storeName, byte[] key){ + String keyHex = "0x" + Hex.toHexString(key); + String path = String.format("\"/store/%s/subspace\"", storeName); + JsonRpcResponse rpcResponse = BinanceDexApiClientGenerator.executeSync(binanceDexNodeApi.abciQuery(path, keyHex)); + checkABCIResponse(rpcResponse); + + return rpcResponse.getResult().getResponse().getValue(); + } + + private List queryStoreSubspaceKVPairs(String storeName, byte[] key) throws IOException { + String keyHex = "0x" + Hex.toHexString(key); + String path = String.format("\"/store/%s/subspace\"", storeName); + JsonRpcResponse rpcResponse = BinanceDexApiClientGenerator.executeSync(binanceDexNodeApi.abciQuery(path, keyHex)); + checkABCIResponse(rpcResponse); + + byte[] result = rpcResponse.getResult().getResponse().getValue(); + + if (!ByteUtil.isEmpty(result)) { + try { + CodedInputStream codedInputStream = CodedInputStream.newInstance(result); + + if (codedInputStream.isAtEnd()){ + return new ArrayList<>(); + } + //read length prefix + int length = codedInputStream.readRawVarint32(); + if (length == 0){ + return new ArrayList<>(); + } + + Types.KVPairs kvPairs = Types.KVPairs.parseFrom(codedInputStream); + + return kvPairs.getPairsList(); + }catch (InvalidProtocolBufferException e){ + throw new IOException("Decode response failed due to: " + e.getMessage()); + } + }else{ + return new ArrayList<>(); + } + } + + private void checkABCIResponse(JsonRpcResponse rpcResponse) { + if (null != rpcResponse.getError() && null != rpcResponse.getError().getCode() && rpcResponse.getError().getCode().intValue() != 0) { + throw new RuntimeException(rpcResponse.getError().toString()); + } + ABCIQueryResult.Response response = rpcResponse.getResult().getResponse(); + if (response.getCode() != null) { + BinanceDexApiError binanceDexApiError = new BinanceDexApiError(); + binanceDexApiError.setCode(response.getCode()); + binanceDexApiError.setMessage(response.getLog()); + throw new BinanceDexApiException(binanceDexApiError); + } + } + +} diff --git a/src/main/proto/dex.proto b/src/main/proto/dex.proto index a46f521..df52727 100644 --- a/src/main/proto/dex.proto +++ b/src/main/proto/dex.proto @@ -7,6 +7,7 @@ option java_outer_classname = "Transaction"; package transaction; import "types.proto"; +import "google/protobuf/timestamp.proto"; // please note the field name is the JSON name. message StdTx { diff --git a/src/main/proto/types.proto b/src/main/proto/types.proto index b48ff1e..680026c 100644 --- a/src/main/proto/types.proto +++ b/src/main/proto/types.proto @@ -315,6 +315,10 @@ message Evidence { int64 total_voting_power = 5; } +message KVPairs { + repeated common.KVPair pairs = 1; +} + //---------------------------------------- // Service Definition diff --git a/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java b/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java new file mode 100644 index 0000000..e58339b --- /dev/null +++ b/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java @@ -0,0 +1,32 @@ +package com.binance.dex.api.client.encoding; + +import com.binance.dex.api.client.encoding.amino.Amino; +import com.binance.dex.api.client.encoding.message.sidechain.query.SideChainRedelegationMessage; +import com.binance.dex.api.client.encoding.message.sidechain.value.RedelegationValue; +import org.bouncycastle.util.encoders.Hex; +import org.junit.Assert; +import org.junit.Test; + +import java.io.IOException; + +/** + * @author Fitz.Lu + **/ +public class AminoTest { + + private final Amino amino = new Amino(); + + @Test + public void testDecodeRedelegation() throws IOException { + String hex = "6e0a148c7c3a06d11eacc857a7b623ca12ed963c5c53e812148c7c3a06d11eacc857a7b623ca12ed963c5c53e81a147fe359f3eaa4d2627069b32c49f854b736343c7220da522a0c08808094f50510d08dad840332080a03424e4210e8073a0b0a03424e4210d285d8cc04420a4a32"; + SideChainRedelegationMessage message = new SideChainRedelegationMessage(); + amino.decodeWithLengthPrefix(Hex.decode(hex), message); + Assert.assertNotNull(message.getDelegatorAddress()); + + hex = "2a08a554120c08c08994f50510a0b0df93011a080a03424e4210904e22090a03424e4210d099052a0a3232"; + RedelegationValue value = new RedelegationValue(); + amino.decodeWithLengthPrefix(Hex.decode(hex), value); + Assert.assertNotNull(value.getSharesDst()); + } + +} diff --git a/src/test/java/com/binance/dex/api/client/examples/SideChainStakingNodeExample.java b/src/test/java/com/binance/dex/api/client/examples/SideChainStakingNodeExample.java new file mode 100644 index 0000000..061dc4f --- /dev/null +++ b/src/test/java/com/binance/dex/api/client/examples/SideChainStakingNodeExample.java @@ -0,0 +1,278 @@ +package com.binance.dex.api.client.examples; + +import com.binance.dex.api.client.BinanceDexApiClientFactory; +import com.binance.dex.api.client.BinanceDexApiNodeClient; +import com.binance.dex.api.client.BinanceDexEnvironment; +import com.binance.dex.api.client.Wallet; +import com.binance.dex.api.client.domain.sidechain.*; +import com.binance.dex.api.client.domain.TransactionMetadata; +import com.binance.dex.api.client.domain.broadcast.*; +import com.binance.dex.api.client.encoding.Crypto; +import com.binance.dex.api.client.encoding.message.*; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import java.io.IOException; +import java.security.NoSuchAlgorithmException; +import java.util.List; + +/** + * @author Fitz.Lu + **/ +public class SideChainStakingNodeExample { + + private BinanceDexApiNodeClient nodeClient = null; + private final Wallet wallet = new Wallet("66d08fc209b31090ea21a8cf9a6e2680b008e2b905b2358ae31e0f42b140de99", BinanceDexEnvironment.TEST_NET); + + @Before + public void setup() { + nodeClient = BinanceDexApiClientFactory.newInstance().newNodeRpcClient(BinanceDexEnvironment.TEST_NET.getNodeUrl(),BinanceDexEnvironment.TEST_NET.getHrp()); + } + + @Test + public void testCreateSideChainValidator(){ + CreateSideChainValidator createSideChainValidator = new CreateSideChainValidator(); + + //create and set description + Description validatorDescription = new Description(); + validatorDescription.setMoniker("custom-moniker"); + validatorDescription.setIdentity("ide"); + validatorDescription.setWebsite("https://www.website.com"); + validatorDescription.setDetails("This is a side-chain validator"); + + createSideChainValidator.setDescription(validatorDescription); + + //create and set commission + Commission commission = new Commission(); + commission.setRate(5L); + commission.setMaxRate(100L); + commission.setMaxChangeRate(5L); + + createSideChainValidator.setCommission(commission); + + //set delegator address, here use self address + createSideChainValidator.setDelegatorAddr(wallet.getAddress()); + + //set delegation token, here use 1000000 BNB + Token delegationToken = new Token(); + delegationToken.setDenom("BNB"); + delegationToken.setAmount(10000000000L); + createSideChainValidator.setDelegation(delegationToken); + + //set side-chain id + createSideChainValidator.setSideChainId("bsc"); + + //set side-chain validator cons address + createSideChainValidator.setSideConsAddr("0xd1B22dCC24C55f4d728E7aaA5c9b5a22e1512C08"); + + //set side-chain validator fee address + createSideChainValidator.setSideFeeAddr("0x9fB29AAc15b9A4B7F17c3385939b007540f4d791"); + + TransactionOption options = new TransactionOption("", 0, null); + + try { + List transactionMetadatas = nodeClient.createSideChainValidator(createSideChainValidator, wallet, options, true); + for (TransactionMetadata transactionMetadata : transactionMetadatas) { + System.out.println(transactionMetadata.toString()); + } + } catch (IOException | NoSuchAlgorithmException e) { + e.printStackTrace(); + } + } + + @Test + public void testEditSideChainValidator(){ + EditSideChainValidator editSideChainValidator = new EditSideChainValidator(); + + //set new description if needed + Description description = new Description(); + description.setMoniker("new Moniker"); + editSideChainValidator.setDescription(description); + + //set new rate if needed + editSideChainValidator.setCommissionRate(1L); + + //set new cons address needed + editSideChainValidator.setSideConsAddr("0x9fB29AAc15b9A4B7F17c3385939b007540f4d791"); + + //set new fee address if needed + editSideChainValidator.setSideFeeAddr("0xd1B22dCC24C55f4d728E7aaA5c9b5a22e1512C08"); + + editSideChainValidator.setSideChainId("bsc"); + + try { + List transactionMetadatas = nodeClient.editSideChainValidator(editSideChainValidator, wallet, createTransactionOptionForTest(), true); + for (TransactionMetadata transactionMetadata : transactionMetadatas) { + consolePrintln(transactionMetadata); + } + }catch (IOException | NoSuchAlgorithmException e){ + e.printStackTrace(); + } + } + + @Test + public void testSideChainDelegate(){ + SideChainDelegate sideChainDelegate = new SideChainDelegate(); + + //set delegate token + Token delegation = new Token("BNB", 100000000L); + sideChainDelegate.setDelegation(delegation); + + //set delegator address, here is self + sideChainDelegate.setDelegatorAddress(wallet.getAddress()); + + //set validator address + sideChainDelegate.setValidatorAddress("bva1337r5pk3r6kvs4a8kc3u5yhdjc79c5lg78343t"); + + //set side-chain id + sideChainDelegate.setSideChainId("bsc"); + + try { + List transactionMetadatas = nodeClient.sideChainDelegate(sideChainDelegate, wallet, createTransactionOptionForTest(), true); + for (TransactionMetadata transactionMetadata : transactionMetadatas) { + consolePrintln(transactionMetadata); + } + }catch (IOException | NoSuchAlgorithmException e){ + e.printStackTrace(); + } + } + + @Test + public void testSideChainRedelegate(){ + SideChainRedelegate redelegate = new SideChainRedelegate(); + + //set redelegate amount + redelegate.setAmount(new Token("bnb".toUpperCase(), 100000000L)); + + //set delegator address + redelegate.setDelegatorAddress(wallet.getAddress()); + + //set source validator address + redelegate.setSrcValidatorAddress("bva1337r5pk3r6kvs4a8kc3u5yhdjc79c5lg78343t"); + + //set destination validator address + redelegate.setDstValidatorAddress("bva10l34nul25nfxyurfkvkyn7z5kumrg0rjun409e"); + + //set side-chain id + redelegate.setSideChainId("bsc"); + + try { + List transactionMetadatas = nodeClient.sideChainRedelagate(redelegate, wallet, createTransactionOptionForTest(), true); + consolePrintln(transactionMetadatas.get(0)); + }catch (IOException | NoSuchAlgorithmException e){ + e.printStackTrace(); + } + } + + @Test + public void testSideChainUnbond(){ + SideChainUnBond sideChainUndelegate = new SideChainUnBond(); + + //set unbond amount + sideChainUndelegate.setAmount(new Token("BNB", 5000L)); + + //set delegator address + sideChainUndelegate.setDelegatorAddress(wallet.getAddress()); + + //set validator address + sideChainUndelegate.setValidatorAddress("bva1337r5pk3r6kvs4a8kc3u5yhdjc79c5lg78343t"); + + //set side-chain id + sideChainUndelegate.setSideChainId("bsc"); + + try { + List transactionMetadatas = nodeClient.sideChainUnbond(sideChainUndelegate, wallet, createTransactionOptionForTest(), true); + consolePrintln(transactionMetadatas.get(0)); + }catch (IOException | NoSuchAlgorithmException e){ + e.printStackTrace(); + } + } + + @Test + public void testGetSideChainValidator() throws IOException { + SideChainValidator validator = nodeClient.getSideChainValidator("bsc", decodeAddress("bva1337r5pk3r6kvs4a8kc3u5yhdjc79c5lg78343t")); + Assert.assertNotNull(validator); + consolePrintln(validator); + } + + @Test + public void testGetSideChainTopValidators() throws IOException { + List validators = nodeClient.getSideChainTopValidators("bsc", 5); + for (SideChainValidator validator : validators) { + consolePrintln(validator); + } + } + + @Test + public void testGetSideChainDelegation() throws IOException { + SideChainDelegation delegation = nodeClient.getSideChainDelegation("bsc", wallet.getAddressBytes(), decodeAddress("bva1337r5pk3r6kvs4a8kc3u5yhdjc79c5lg78343t")); + Assert.assertNotNull(delegation); + consolePrintln(delegation); + } + + @Test + public void testGetSideChainDelegations() throws IOException { + List delegations = nodeClient.getSideChainDelegations("bsc", wallet.getAddressBytes()); + for (SideChainDelegation delegation : delegations) { + consolePrintln(delegation); + } + } + + @Test + public void getSideChainRedelegation() throws IOException { + byte[] srcValidatorAddress = decodeAddress("bva1337r5pk3r6kvs4a8kc3u5yhdjc79c5lg78343t"); + byte[] dstValidatorAddress = decodeAddress("bva10l34nul25nfxyurfkvkyn7z5kumrg0rjun409e"); + + SideChainRedelegation redelegation = nodeClient.getSideChainRedelegation("bsc", wallet.getAddressBytes(), srcValidatorAddress, dstValidatorAddress); + if (redelegation != null) { + consolePrintln(redelegation); + } + } + + @Test + public void getSideChainRedelegations() throws IOException { + List redelegations = nodeClient.getSideChainRedelegations("bsc", wallet.getAddressBytes()); + for (SideChainRedelegation redelegation : redelegations) { + consolePrintln(redelegation); + } + } + + @Test + public void getSideChainUnBondingDelegation() throws IOException { + SideChainUnBondingDelegation unBondingDelegation = nodeClient.getSideChainUnBondingDelegation("bsc", wallet.getAddressBytes(), decodeAddress("bva1337r5pk3r6kvs4a8kc3u5yhdjc79c5lg78343t")); + consolePrintln(unBondingDelegation); + } + + @Test + public void getSideChainUnBondingDelegations() throws IOException { + List unBondingDelegations = nodeClient.getSideChainUnBondingDelegations("bsc", wallet.getAddressBytes()); + for (SideChainUnBondingDelegation unBondingDelegation : unBondingDelegations) { + consolePrintln(unBondingDelegation); + } + } + + private byte[] decodeAddress(String address){ + return Crypto.decodeAddress(address); + } + + /** + * Print message to console for debug, call + * its toString() method. + * + * @param message the specify message object + * */ + private void consolePrintln(Object message){ + System.out.println(message.toString()); + } + + /** + * Create a transaction option for test + * + * @return TransactionOption + * */ + private TransactionOption createTransactionOptionForTest(){ + return new TransactionOption("", 0, null); + } + +} From 4e7738061ad4b60f56ff3eace49b88c85d8d20f7 Mon Sep 17 00:00:00 2001 From: FitzLu Date: Sun, 26 Apr 2020 19:32:41 +0800 Subject: [PATCH 03/52] add sidechain bridge and oracle --- pom.xml | 2 +- .../client/BinanceDexApiClientFactory.java | 6 +- .../api/client/BinanceDexApiNodeClient.java | 83 ++--- .../dex/api/client/BinanceDexEnvironment.java | 15 +- .../dex/api/client/TransactionConverter.java | 303 ++++++++++++++++- .../dex/api/client/domain/bridge/Bind.java | 82 +++++ .../api/client/domain/bridge/TransferIn.java | 81 +++++ .../api/client/domain/bridge/TransferOut.java | 62 ++++ .../api/client/domain/broadcast/TxType.java | 10 +- .../api/client/domain/oracle/ClaimMsg.java | 57 ++++ .../api/client/domain/oracle/Prophecy.java | 59 ++++ .../dex/api/client/domain/oracle/Status.java | 35 ++ .../{sidechain => stake}/Commission.java | 2 +- .../{sidechain => stake}/Description.java | 2 +- .../dex/api/client/domain/stake/Pool.java | 38 +++ .../sidechain/CreateSideChainValidator.java | 28 +- .../sidechain/EditSideChainValidator.java | 35 +- .../sidechain/SideChainDelegate.java | 12 +- .../sidechain/SideChainDelegation.java | 20 +- .../sidechain/SideChainRedelegate.java | 13 +- .../sidechain/SideChainRedelegation.java | 49 ++- .../sidechain/SideChainUnBond.java | 12 +- .../sidechain/SideChainValidator.java | 47 +-- .../sidechain/UnBondingDelegation.java} | 35 +- .../dex/api/client/encoding/Crypto.java | 14 + .../dex/api/client/encoding/amino/Amino.java | 32 +- .../client/encoding/amino/InternalAmino.java | 14 + .../api/client/encoding/amino/WireType.java | 55 +-- .../message/BinanceDexTransactionMessage.java | 7 + .../client/encoding/message/MessageType.java | 5 +- .../api/client/encoding/message/Token.java | 2 + .../message/TransactionRequestAssembler.java | 122 +------ .../message/bridge/BindMsgMessage.java | 164 +++++++++ .../encoding/message/bridge/BindStatus.java | 13 + .../message/bridge/ClaimMsgMessage.java | 125 +++++++ .../encoding/message/bridge/ClaimType.java | 14 + .../encoding/message/bridge/ClaimTypes.java | 41 +++ .../encoding/message/bridge/DBProphecy.java | 84 +++++ .../encoding/message/bridge/RefundReason.java | 13 + .../encoding/message/bridge/StatusValue.java | 58 ++++ .../bridge/TransferInClaimMessage.java | 93 +++++ .../message/bridge/TransferOutMsgMessage.java | 117 +++++++ .../bridge/UpdateBindClaimMessage.java | 87 +++++ .../bridge/UpdateTransferOutClaimMessage.java | 87 +++++ .../message/common/Bech32AddressValue.java | 94 ++++++ .../value => common}/CoinValue.java | 8 +- .../CoinValueStr.java} | 39 ++- .../{sidechain/value => common}/Dec.java | 3 +- .../EthAddressValue.java} | 36 +- .../sidechain/SideChainClassConverter.java | 75 ----- .../sidechain/query/BaseQueryParams.java | 27 ++ .../sidechain/query/BechValidator.java | 16 +- .../message/sidechain/query/PoolMessage.java | 60 ++++ .../sidechain/query/QueryValidatorParams.java | 43 +++ .../query/SideChainRedelegationMessage.java | 119 ++----- .../SideChainUnBondingDelegationMessage.java | 69 ---- .../query/SideChainValidatorMessage.java | 2 +- .../query/UnBondingDelegationMessage.java | 83 +++++ .../CreateSideChainValidatorMessage.java | 44 +-- .../EditSideChainValidatorMessage.java | 49 ++- .../transaction/SideChainDelegateMessage.java | 46 +-- .../SideChainRedelegateMessage.java | 58 ++-- .../SideChainUndelegateMessage.java | 45 +-- .../sidechain/value/CommissionMsgValue.java | 1 + .../sidechain/value/DelegationValue.java | 1 + .../sidechain/value/RedelegationValue.java | 22 +- .../sidechain/value/UnBondingValue.java | 21 +- .../AccAddressValueToStringSerializer.java | 21 -- .../Bech32AddressValueToStringSerializer.java | 22 ++ .../serializer/DecToStringSerializer.java | 2 +- .../EthAddressValueToStringSerializer.java | 20 ++ .../ValAddressValueToStringSerializer.java | 23 -- .../impl/BinanceDexApiNodeClientImpl.java | 183 ++++++---- .../client/impl/node/NodeQueryDelegate.java | 107 ++++++ .../impl/node/NodeQueryDelegateOracle.java | 91 +++++ .../NodeQueryDelegateSideChainStaking.java} | 295 +++++++++------- .../api/client/impl/node/NodeTxDelegate.java | 146 ++++++++ .../impl/node/NodeTxDelegateBridge.java | 119 +++++++ .../node/NodeTxDelegateSideChainStaking.java | 175 ++++++++++ .../websocket/BinanceDexClientWSFactory.java | 4 +- .../client/websocket/BinanceDexWSApiImpl.java | 6 +- src/main/proto/dex.proto | 13 + .../dex/api/client/encoding/AminoTest.java | 317 +++++++++++++++++- .../client/examples/BridgeNodeExample.java | 190 +++++++++++ .../client/examples/NodeClientExample.java | 2 +- .../examples/SideChainStakingNodeExample.java | 108 +++--- 86 files changed, 4117 insertions(+), 923 deletions(-) create mode 100644 src/main/java/com/binance/dex/api/client/domain/bridge/Bind.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/bridge/TransferIn.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/bridge/TransferOut.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/oracle/ClaimMsg.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/oracle/Prophecy.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/oracle/Status.java rename src/main/java/com/binance/dex/api/client/domain/{sidechain => stake}/Commission.java (96%) rename src/main/java/com/binance/dex/api/client/domain/{sidechain => stake}/Description.java (96%) create mode 100644 src/main/java/com/binance/dex/api/client/domain/stake/Pool.java rename src/main/java/com/binance/dex/api/client/domain/{ => stake}/sidechain/CreateSideChainValidator.java (61%) rename src/main/java/com/binance/dex/api/client/domain/{ => stake}/sidechain/EditSideChainValidator.java (55%) rename src/main/java/com/binance/dex/api/client/domain/{ => stake}/sidechain/SideChainDelegate.java (76%) rename src/main/java/com/binance/dex/api/client/domain/{ => stake}/sidechain/SideChainDelegation.java (65%) rename src/main/java/com/binance/dex/api/client/domain/{ => stake}/sidechain/SideChainRedelegate.java (73%) rename src/main/java/com/binance/dex/api/client/domain/{ => stake}/sidechain/SideChainRedelegation.java (59%) rename src/main/java/com/binance/dex/api/client/domain/{ => stake}/sidechain/SideChainUnBond.java (71%) rename src/main/java/com/binance/dex/api/client/domain/{ => stake}/sidechain/SideChainValidator.java (76%) rename src/main/java/com/binance/dex/api/client/domain/{sidechain/SideChainUnBondingDelegation.java => stake/sidechain/UnBondingDelegation.java} (63%) create mode 100644 src/main/java/com/binance/dex/api/client/encoding/amino/InternalAmino.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/bridge/BindMsgMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/bridge/BindStatus.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/bridge/ClaimMsgMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/bridge/ClaimType.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/bridge/ClaimTypes.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/bridge/DBProphecy.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/bridge/RefundReason.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/bridge/StatusValue.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/bridge/TransferInClaimMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/bridge/TransferOutMsgMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/bridge/UpdateBindClaimMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/bridge/UpdateTransferOutClaimMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/common/Bech32AddressValue.java rename src/main/java/com/binance/dex/api/client/encoding/message/{sidechain/value => common}/CoinValue.java (86%) rename src/main/java/com/binance/dex/api/client/encoding/message/{sidechain/value/TokenMessageValue.java => common/CoinValueStr.java} (68%) rename src/main/java/com/binance/dex/api/client/encoding/message/{sidechain/value => common}/Dec.java (94%) rename src/main/java/com/binance/dex/api/client/encoding/message/{sidechain/value/AddressValue.java => common/EthAddressValue.java} (67%) delete mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/SideChainClassConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/BaseQueryParams.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/PoolMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryValidatorParams.java delete mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/SideChainUnBondingDelegationMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/UnBondingDelegationMessage.java delete mode 100644 src/main/java/com/binance/dex/api/client/encoding/serializer/AccAddressValueToStringSerializer.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/serializer/Bech32AddressValueToStringSerializer.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/serializer/EthAddressValueToStringSerializer.java delete mode 100644 src/main/java/com/binance/dex/api/client/encoding/serializer/ValAddressValueToStringSerializer.java create mode 100644 src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegate.java create mode 100644 src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegateOracle.java rename src/main/java/com/binance/dex/api/client/impl/{BinanceDexApiNodeClientImplSideChainQueryDelegate.java => node/NodeQueryDelegateSideChainStaking.java} (58%) create mode 100644 src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegate.java create mode 100644 src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegateBridge.java create mode 100644 src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegateSideChainStaking.java create mode 100644 src/test/java/com/binance/dex/api/client/examples/BridgeNodeExample.java diff --git a/pom.xml b/pom.xml index fdbc174..998cece 100644 --- a/pom.xml +++ b/pom.xml @@ -5,7 +5,7 @@ com.binance.dex.api binance-dex-api-client - 1.0.6 + 1.1.0 2.6.0 diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexApiClientFactory.java b/src/main/java/com/binance/dex/api/client/BinanceDexApiClientFactory.java index 523e18a..f503b55 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexApiClientFactory.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexApiClientFactory.java @@ -26,11 +26,11 @@ public BinanceDexApiRestClient newRestClient(String baseUrl,String apiKey){ } public BinanceDexApiNodeClient newNodeRpcClient() { - return newNodeRpcClient(BinanceDexEnvironment.PROD.getNodeUrl(), BinanceDexEnvironment.PROD.getHrp()); + return newNodeRpcClient(BinanceDexEnvironment.PROD.getNodeUrl(), BinanceDexEnvironment.PROD.getHrp(), BinanceDexEnvironment.PROD.getValHrp()); } - public BinanceDexApiNodeClient newNodeRpcClient(String baseUrl, String hrp) { - return new BinanceDexApiNodeClientImpl(baseUrl, hrp); + public BinanceDexApiNodeClient newNodeRpcClient(String baseUrl, String hrp, String valHrp) { + return new BinanceDexApiNodeClientImpl(baseUrl, hrp, valHrp); } public BinanceDexApiAsyncRestClient newAsyncRestClient() { diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java b/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java index 57a0d17..b8d7030 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java @@ -1,14 +1,18 @@ package com.binance.dex.api.client; import com.binance.dex.api.client.domain.*; +import com.binance.dex.api.client.domain.bridge.TransferIn; import com.binance.dex.api.client.domain.broadcast.*; import com.binance.dex.api.client.domain.broadcast.Transaction; +import com.binance.dex.api.client.domain.oracle.Prophecy; import com.binance.dex.api.client.domain.request.ClosedOrdersRequest; import com.binance.dex.api.client.domain.request.OpenOrdersRequest; import com.binance.dex.api.client.domain.request.TradesRequest; import com.binance.dex.api.client.domain.request.TransactionsRequest; -import com.binance.dex.api.client.domain.sidechain.*; +import com.binance.dex.api.client.domain.stake.Pool; +import com.binance.dex.api.client.domain.stake.sidechain.*; +import javax.annotation.Nullable; import java.io.IOException; import java.security.NoSuchAlgorithmException; import java.util.List; @@ -159,56 +163,55 @@ default List unfreeze(TokenUnfreeze unfreeze, Wallet wallet throw new UnsupportedOperationException(); } - default List createSideChainValidator(CreateSideChainValidator createSideChainValidator, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { - throw new UnsupportedOperationException(); - } + List createSideChainValidator(CreateSideChainValidator createSideChainValidator, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; - default List editSideChainValidator(EditSideChainValidator editSideChainValidator, Wallet wallet, TransactionOption option, boolean synv) throws IOException, NoSuchAlgorithmException { - throw new UnsupportedOperationException(); - } + List editSideChainValidator(EditSideChainValidator editSideChainValidator, Wallet wallet, TransactionOption option, boolean synv) throws IOException, NoSuchAlgorithmException ; - default List sideChainDelegate(SideChainDelegate sideChainDelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { - throw new UnsupportedOperationException(); - } + List sideChainDelegate(SideChainDelegate sideChainDelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; - default List sideChainRedelagate(SideChainRedelegate sideChainRedelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { - throw new UnsupportedOperationException(); - } + List sideChainRedelagate(SideChainRedelegate sideChainRedelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; - default List sideChainUnbond(SideChainUnBond sideChainUndelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { - throw new UnsupportedOperationException(); - } + List sideChainUnbond(SideChainUnBond sideChainUndelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; - default SideChainValidator getSideChainValidator(String sideChainId, byte[] validatorAddress) throws IOException { - throw new UnsupportedOperationException(); - } + SideChainValidator getSideChainValidator(String sideChainId, String validatorAddress) throws IOException; - default List getSideChainTopValidators(String sideChainId, int top) throws IOException { - throw new UnsupportedOperationException(); - } + List getSideChainTopValidators(String sideChainId, int top) throws IOException ; - default SideChainDelegation getSideChainDelegation(String sideChainId, byte[] delegatorAddress, byte[] validatorAddress) throws IOException { - throw new UnsupportedOperationException(); - } + SideChainDelegation getSideChainDelegation(String sideChainId, String delegatorAddress, String validatorAddress) throws IOException; - default List getSideChainDelegations(String sideChainId, byte[] delegatorAddress) throws IOException { - throw new UnsupportedOperationException(); - } + List getSideChainDelegations(String sideChainId, String delegatorAddress) throws IOException; - default SideChainRedelegation getSideChainRedelegation(String sideChainId, byte[] delegatorAddress, byte[] srcValidatorAddress, byte[] dstValidatorAddress) throws IOException { - throw new UnsupportedOperationException(); - } + SideChainRedelegation getSideChainRedelegation(String sideChainId, String delegatorAddress, String srcValidatorAddress, String dstValidatorAddress) throws IOException; - default List getSideChainRedelegations(String sideChainId, byte[] delegatorAddress) throws IOException { - throw new UnsupportedOperationException(); - } + List getSideChainRedelegations(String sideChainId, String delegatorAddress) throws IOException; - default SideChainUnBondingDelegation getSideChainUnBondingDelegation(String sideChainId, byte[] delegatorAddress, byte[] validatorAddress) throws IOException { - throw new UnsupportedOperationException(); - } + UnBondingDelegation getSideChainUnBondingDelegation(String sideChainId, String delegatorAddress, String validatorAddress) throws IOException; - default List getSideChainUnBondingDelegations(String sideChainId, byte[] delegatorAddress) throws IOException { - throw new UnsupportedOperationException(); - } + List getSideChainUnBondingDelegations(String sideChainId, String delegatorAddress) throws IOException; + + List getSideChainUnBondingDelegationsByValidator(String sideChainId, String validatorAddress) throws IOException ; + + List getSideChainRedelegationsByValidator(String sideChainId, String validatorAddress) throws IOException; + + Pool getSideChainPool(String sideChainId) throws IOException; + + long getAllSideChainValidatorsCount(String sideChainId, boolean jailInvolved) throws IOException; + + List claim(int claimType, String claim, long sequence, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; + + @Nullable + Prophecy getProphecy(int claimType, long sequence) throws IOException; + + long getCurrentSequence(int claimType); + + List transferIn(long sequence, TransferIn transferIn, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; + + List transferOut(String toAddress, com.binance.dex.api.client.encoding.message.Token amount, long expireTimeInSeconds, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; + + List bind(String symbol, long amount, String contractAddress, int contractDecimal, long expireTimeInSeconds, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; + + List updateTransferOut(long sequence, String refundAddress, com.binance.dex.api.client.encoding.message.Token amount, int refundReason, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; + + List updateBind(long sequence, String symbol, String contractAddress, int status, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; } diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexEnvironment.java b/src/main/java/com/binance/dex/api/client/BinanceDexEnvironment.java index 5c8c2ac..e835fbf 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexEnvironment.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexEnvironment.java @@ -9,14 +9,16 @@ public class BinanceDexEnvironment { "wss://dex.binance.org/api", "https://dataseed1.ninicoin.io", "wss://dataseed1.ninicoin.io/websocket", - "bnb" + "bnb", + "bva" ); public static final BinanceDexEnvironment TEST_NET = new BinanceDexEnvironment( "https://testnet-dex.binance.org", "wss://testnet-dex.binance.org/api", "http://data-seed-pre-0-s3.binance.org", "wss://data-seed-pre-0-s3.binance.org/websocket", - "tbnb" + "tbnb", + "tbva" ); // Rest API base URL @@ -29,13 +31,16 @@ public class BinanceDexEnvironment { private String wsBaseUrl; // Address human readable part prefix private String hrp; + // Address human readable part prefix for validator + private String valHrp; - public BinanceDexEnvironment(String baseUrl, String streamUrl, String nodeUrl, String wsBaseUrl, String hrp) { + public BinanceDexEnvironment(String baseUrl, String streamUrl, String nodeUrl, String wsBaseUrl, String hrp, String valHrp) { this.baseUrl = baseUrl; this.streamUrl = streamUrl; this.nodeUrl = nodeUrl; this.wsBaseUrl = wsBaseUrl; this.hrp = hrp; + this.valHrp = valHrp; } public String getBaseUrl() { @@ -54,6 +59,10 @@ public String getHrp() { return hrp; } + public String getValHrp() { + return valHrp; + } + @Override public boolean equals(Object o) { if (this == o) return true; diff --git a/src/main/java/com/binance/dex/api/client/TransactionConverter.java b/src/main/java/com/binance/dex/api/client/TransactionConverter.java index 960ed76..b991a3a 100644 --- a/src/main/java/com/binance/dex/api/client/TransactionConverter.java +++ b/src/main/java/com/binance/dex/api/client/TransactionConverter.java @@ -1,6 +1,8 @@ package com.binance.dex.api.client; import com.binance.dex.api.client.domain.*; +import com.binance.dex.api.client.domain.bridge.Bind; +import com.binance.dex.api.client.domain.bridge.TransferOut; import com.binance.dex.api.client.domain.broadcast.*; import com.binance.dex.api.client.domain.broadcast.Burn; import com.binance.dex.api.client.domain.broadcast.CancelOrder; @@ -17,10 +19,20 @@ import com.binance.dex.api.client.domain.broadcast.Transaction; import com.binance.dex.api.client.domain.broadcast.Vote; import com.binance.dex.api.client.domain.jsonrpc.TxResult; +import com.binance.dex.api.client.domain.oracle.ClaimMsg; +import com.binance.dex.api.client.domain.stake.Commission; +import com.binance.dex.api.client.domain.stake.Description; +import com.binance.dex.api.client.domain.stake.sidechain.*; +import com.binance.dex.api.client.encoding.ByteUtil; import com.binance.dex.api.client.encoding.Crypto; +import com.binance.dex.api.client.encoding.amino.Amino; import com.binance.dex.api.client.encoding.message.InputOutput; import com.binance.dex.api.client.encoding.message.MessageType; import com.binance.dex.api.client.encoding.message.Token; +import com.binance.dex.api.client.encoding.message.bridge.BindMsgMessage; +import com.binance.dex.api.client.encoding.message.bridge.ClaimMsgMessage; +import com.binance.dex.api.client.encoding.message.bridge.TransferOutMsgMessage; +import com.binance.dex.api.client.encoding.message.sidechain.transaction.*; import com.binance.dex.api.proto.*; import com.binance.dex.api.proto.TimeLock; import com.binance.dex.api.proto.TimeRelock; @@ -28,6 +40,7 @@ import com.google.protobuf.InvalidProtocolBufferException; import org.bouncycastle.util.encoders.Hex; +import java.io.IOException; import java.time.Instant; import java.util.*; import java.util.List; @@ -37,8 +50,13 @@ public class TransactionConverter { private String hrp; - public TransactionConverter(String hrp){ + private String valHrp; + + private final Amino amino = new Amino(); + + public TransactionConverter(String hrp, String valHrp){ this.hrp = hrp; + this.valHrp = valHrp; } public List convert(com.binance.dex.api.client.domain.jsonrpc.BlockInfoResult.Transaction txMessage) { @@ -164,7 +182,23 @@ public Transaction convert(byte[] bytes) { return convertClaimHashTimerLock(bytes); case RefundHashTimerLockMsg: return convertRefundHashTimerLock(bytes); - + case CreateSideChainValidator: + return convertCreateSideChainValidator(bytes); + case EditSideChainValidator: + return convertEditSideChainValidator(bytes); + case SideChainDelegate: + return convertSideChainDelegate(bytes); + case SideChainRedelegate: + return convertSideChainRedelegate(bytes); + case SideChainUndelegate: + return convertSideChainUnBond(bytes); + case Claim: + //transfer in, update transfer out, update bind + return convertClaimMsg(bytes); + case TransferOut: + return convertTransferOutMsg(bytes); + case Bind: + return convertBindMsg(bytes); } return null; } catch (Exception e) { @@ -172,6 +206,271 @@ public Transaction convert(byte[] bytes) { } } + private Transaction convertBindMsg(byte[] value) throws IOException { + byte[] raw = ByteUtil.cut(value, 4); + BindMsgMessage message = new BindMsgMessage(); + amino.decodeBare(raw, message); + + Bind bind = new Bind(); + if (message.getFrom() != null && message.getFrom().getRaw() != null){ + bind.setFrom(Crypto.encodeAddress(hrp, message.getFrom().getRaw())); + } + bind.setSymbol(message.getSymbol()); + bind.setAmount(message.getAmount()); + if (message.getContractAddress() != null) { + bind.setContractAddress(message.getContractAddress().getAddress()); + } + bind.setContractDecimal(message.getContractDecimal()); + bind.setExpireTime(message.getExpireTime()); + + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.BIND); + transaction.setRealTx(bind); + + return transaction; + } + + private Transaction convertTransferOutMsg(byte[] value) throws IOException { + byte[] raw = ByteUtil.cut(value, 4); + TransferOutMsgMessage message = new TransferOutMsgMessage(); + amino.decodeBare(raw, message); + + TransferOut transferOut = new TransferOut(); + if (message.getFrom() != null && message.getFrom().getRaw() != null){ + transferOut.setFrom(Crypto.encodeAddress(hrp, message.getFrom().getRaw())); + } + if (message.getToAddress() != null){ + transferOut.setToAddress(message.getToAddress().getAddress()); + } + + Token token = new Token(); + if (message.getAmount() != null){ + token.setAmount(message.getAmount().getAmount()); + token.setDenom(message.getAmount().getDenom()); + } + transferOut.setAmount(token); + + transferOut.setExpireTime(message.getExpireTime()); + + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.TRANSFER_OUT); + transaction.setRealTx(transferOut); + + return transaction; + } + + private Transaction convertClaimMsg(byte[] value) throws IOException { + byte[] raw = ByteUtil.cut(value, 4); + ClaimMsgMessage message = new ClaimMsgMessage(); + amino.decodeBare(raw, message); + ClaimMsg claimMsg = new ClaimMsg(); + claimMsg.setClaimType(message.getClaimType()); + claimMsg.setSequence(message.getSequence()); + claimMsg.setClaim(message.getClaim()); + if (message.getValidatorAddress().getRaw() != null) { + claimMsg.setValidatorAddress(Crypto.encodeAddress(valHrp, message.getValidatorAddress().getRaw())); + } + + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.CLAIM); + transaction.setRealTx(claimMsg); + + return transaction; + } + + private Transaction convertSideChainUnBond(byte[] value) throws IOException { + byte[] raw = ByteUtil.cut(value, 4); + SideChainUndelegateMessage message = new SideChainUndelegateMessage(); + amino.decodeBare(raw, message); + + SideChainUnBond unBond = new SideChainUnBond(); + + if (message.getDelegatorAddress() != null && message.getDelegatorAddress().getRaw() != null){ + unBond.setDelegatorAddress(Crypto.encodeAddress(hrp, message.getDelegatorAddress().getRaw())); + } + + if (message.getValidatorAddress() != null && message.getValidatorAddress().getRaw() != null){ + unBond.setValidatorAddress(Crypto.encodeAddress(valHrp, message.getValidatorAddress().getRaw())); + } + + Token amount = new Token(); + if (message.getAmount() != null){ + amount.setAmount(message.getAmount().getAmount()); + amount.setDenom(message.getAmount().getDenom()); + } + unBond.setAmount(amount); + + unBond.setSideChainId(message.getSideChainId()); + + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.SIDECHAIN_UNBOND); + transaction.setRealTx(unBond); + + return transaction; + } + + private Transaction convertSideChainRedelegate(byte[] value) throws IOException { + byte[] raw = ByteUtil.cut(value, 4); + SideChainRedelegateMessage message = new SideChainRedelegateMessage(); + amino.decodeBare(raw, message); + + SideChainRedelegate redelegate = new SideChainRedelegate(); + if (message.getDelegatorAddress() != null && message.getDelegatorAddress().getRaw() != null){ + redelegate.setDelegatorAddress(Crypto.encodeAddress(hrp, message.getDelegatorAddress().getRaw())); + } + + if (message.getSrcValidatorAddress() != null && message.getSrcValidatorAddress().getRaw() != null){ + redelegate.setSrcValidatorAddress(Crypto.encodeAddress(valHrp, message.getSrcValidatorAddress().getRaw())); + } + + if (message.getDstValidatorAddress() != null && message.getDstValidatorAddress().getRaw() != null){ + redelegate.setDstValidatorAddress(Crypto.encodeAddress(valHrp, message.getDstValidatorAddress().getRaw())); + } + + Token amount = new Token(); + if (message.getAmount() != null){ + amount.setAmount(message.getAmount().getAmount()); + amount.setDenom(message.getAmount().getDenom()); + } + redelegate.setAmount(amount); + + redelegate.setSideChainId(message.getSideChainId()); + + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.SIDECHAIN_REDELEGATE); + transaction.setRealTx(redelegate); + + return transaction; + } + + private Transaction convertSideChainDelegate(byte[] value) throws IOException { + byte[] raw = ByteUtil.cut(value, 4); + SideChainDelegateMessage message = new SideChainDelegateMessage(); + amino.decodeBare(raw, message); + + SideChainDelegate sideChainDelegate = new SideChainDelegate(); + if (message.getDelegatorAddress() != null && message.getDelegatorAddress().getRaw() != null){ + sideChainDelegate.setDelegatorAddress(Crypto.encodeAddress(hrp, message.getDelegatorAddress().getRaw())); + } + + if (message.getValidatorAddress() != null && message.getValidatorAddress().getRaw() != null){ + sideChainDelegate.setValidatorAddress(Crypto.encodeAddress(valHrp, message.getValidatorAddress().getRaw())); + } + + Token token = new Token(); + if (message.getDelegation() != null){ + token.setDenom(message.getDelegation().getDenom()); + token.setAmount(message.getDelegation().getAmount()); + } + sideChainDelegate.setDelegation(token); + + sideChainDelegate.setSideChainId(message.getSideChainId()); + + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.SIDECHAIN_DELEGATE); + transaction.setRealTx(sideChainDelegate); + + return transaction; + } + + private Transaction convertEditSideChainValidator(byte[] value) throws IOException { + byte[] raw = ByteUtil.cut(value, 4); + EditSideChainValidatorMessage message = new EditSideChainValidatorMessage(); + amino.decodeBare(raw, message); + + EditSideChainValidator editSideChainValidator = new EditSideChainValidator(); + + Description description = new Description(); + if (message.getDescription() != null){ + description.setMoniker(message.getDescription().getMoniker()); + description.setDetails(message.getDescription().getDetails()); + description.setIdentity(message.getDescription().getIdentity()); + description.setWebsite(message.getDescription().getWebsite()); + } + editSideChainValidator.setDescription(description); + + if (message.getValidatorOperatorAddress() != null && message.getValidatorOperatorAddress().getRaw() != null){ + editSideChainValidator.setValidatorAddress(Crypto.encodeAddress(valHrp, message.getValidatorOperatorAddress().getRaw())); + } + + if (message.getCommissionRate() != null){ + editSideChainValidator.setCommissionRate(message.getCommissionRate().getValue()); + } + + editSideChainValidator.setSideChainId(message.getSideChainId()); + + if (message.getSideFeeAddr() != null) { + editSideChainValidator.setSideFeeAddr("0x" + Hex.toHexString(message.getSideFeeAddr())); + } + + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.EDIT_SIDECHAIN_VALIDATOR); + transaction.setRealTx(editSideChainValidator); + + return transaction; + } + + private Transaction convertCreateSideChainValidator(byte[] value) throws IOException { + byte[] raw = ByteUtil.cut(value, 4); + CreateSideChainValidatorMessage message = new CreateSideChainValidatorMessage(); + amino.decodeBare(raw, message); + + CreateSideChainValidator createSideChainValidator = new CreateSideChainValidator(); + + Description description = new Description(); + if (message.getDescription() != null){ + description.setMoniker(message.getDescription().getMoniker()); + description.setDetails(message.getDescription().getDetails()); + description.setIdentity(message.getDescription().getIdentity()); + description.setWebsite(message.getDescription().getWebsite()); + } + createSideChainValidator.setDescription(description); + + Commission commission = new Commission(); + if (message.getCommission() != null){ + try { + commission.setRate(message.getCommission().getRate().getValue()); + commission.setMaxRate(message.getCommission().getMaxRate().getValue()); + commission.setMaxChangeRate(message.getCommission().getMaxChangeRate().getValue()); + }catch (NullPointerException e){ + //ignore + } + } + createSideChainValidator.setCommission(commission); + + if (message.getDelegatorAddr() != null && message.getDelegatorAddr().getRaw() != null){ + createSideChainValidator.setDelegatorAddr(Crypto.encodeAddress(hrp, message.getDelegatorAddr().getRaw())); + } + + if (message.getValidatorOperatorAddr() != null && message.getValidatorOperatorAddr().getRaw() != null){ + createSideChainValidator.setValidatorAddr(Crypto.encodeAddress(valHrp, message.getValidatorOperatorAddr().getRaw())); + } + + Token delegation = new Token(); + if (message.getDelegation() != null){ + delegation.setAmount(message.getDelegation().getAmount()); + delegation.setDenom(message.getDelegation().getDenom()); + } + createSideChainValidator.setDelegation(delegation); + + createSideChainValidator.setSideChainId(message.getSideChainId()); + + if (message.getSideConsAddr() != null) { + createSideChainValidator.setSideConsAddr("0x" + Hex.toHexString(message.getSideConsAddr())); + } + + if (message.getSideFeeAddr() != null) { + createSideChainValidator.setSideFeeAddr("0x" + Hex.toHexString(message.getSideFeeAddr())); + } + + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.CREATE_SIDECHAIN_VALIDATOR); + transaction.setRealTx(createSideChainValidator); + return transaction; + } + + + private Transaction convertRefundHashTimerLock(byte[] value) throws InvalidProtocolBufferException { byte[] array = new byte[value.length - 4]; System.arraycopy(value, 4, array, 0, array.length); diff --git a/src/main/java/com/binance/dex/api/client/domain/bridge/Bind.java b/src/main/java/com/binance/dex/api/client/domain/bridge/Bind.java new file mode 100644 index 0000000..ee84a8e --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/bridge/Bind.java @@ -0,0 +1,82 @@ +package com.binance.dex.api.client.domain.bridge; + +/** + * @author Fitz.Lu + **/ +public class Bind { + + private String from; + + private String symbol; + + private long amount; + + private String contractAddress; + + private int contractDecimal; + + private long expireTime; + + public Bind() { + } + + public String getFrom() { + return from; + } + + public void setFrom(String from) { + this.from = from; + } + + public String getSymbol() { + return symbol; + } + + public void setSymbol(String symbol) { + this.symbol = symbol; + } + + public long getAmount() { + return amount; + } + + public void setAmount(long amount) { + this.amount = amount; + } + + public String getContractAddress() { + return contractAddress; + } + + public void setContractAddress(String contractAddress) { + this.contractAddress = contractAddress; + } + + public int getContractDecimal() { + return contractDecimal; + } + + public void setContractDecimal(int contractDecimal) { + this.contractDecimal = contractDecimal; + } + + public long getExpireTime() { + return expireTime; + } + + public void setExpireTime(long expireTime) { + this.expireTime = expireTime; + } + + @Override + public String toString() { + return "Bind{" + + "from='" + from + '\'' + + ", symbol='" + symbol + '\'' + + ", amount=" + amount + + ", contractAddress='" + contractAddress + '\'' + + ", contractDecimal=" + contractDecimal + + ", expireTime=" + expireTime + + '}'; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/bridge/TransferIn.java b/src/main/java/com/binance/dex/api/client/domain/bridge/TransferIn.java new file mode 100644 index 0000000..40dd2fe --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/bridge/TransferIn.java @@ -0,0 +1,81 @@ +package com.binance.dex.api.client.domain.bridge; + +import com.binance.dex.api.client.encoding.message.Token; + +import java.util.List; + +/** + * @author Fitz.Lu + **/ +public class TransferIn { + + private String contractAddress; + + private List refundAddresses; + + private List receiverAddresses; + + private List amounts; + + private String symbol; + + private Token relayFee; + + private long expireTime; + + public String getContractAddress() { + return contractAddress; + } + + public void setContractAddress(String contractAddress) { + this.contractAddress = contractAddress; + } + + public List getRefundAddresses() { + return refundAddresses; + } + + public void setRefundAddresses(List refundAddresses) { + this.refundAddresses = refundAddresses; + } + + public List getReceiverAddresses() { + return receiverAddresses; + } + + public void setReceiverAddresses(List receiverAddresses) { + this.receiverAddresses = receiverAddresses; + } + + public List getAmounts() { + return amounts; + } + + public void setAmounts(List amounts) { + this.amounts = amounts; + } + + public String getSymbol() { + return symbol; + } + + public void setSymbol(String symbol) { + this.symbol = symbol; + } + + public Token getRelayFee() { + return relayFee; + } + + public void setRelayFee(Token relayFee) { + this.relayFee = relayFee; + } + + public long getExpireTime() { + return expireTime; + } + + public void setExpireTime(long expireTime) { + this.expireTime = expireTime; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/bridge/TransferOut.java b/src/main/java/com/binance/dex/api/client/domain/bridge/TransferOut.java new file mode 100644 index 0000000..589d42d --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/bridge/TransferOut.java @@ -0,0 +1,62 @@ +package com.binance.dex.api.client.domain.bridge; + +import com.binance.dex.api.client.encoding.message.Token; + +/** + * @author Fitz.Lu + **/ +public class TransferOut { + + private String from; + + private String toAddress; + + private Token amount; + + private long expireTime; + + public TransferOut() { + } + + public String getFrom() { + return from; + } + + public void setFrom(String from) { + this.from = from; + } + + public String getToAddress() { + return toAddress; + } + + public void setToAddress(String toAddress) { + this.toAddress = toAddress; + } + + public Token getAmount() { + return amount; + } + + public void setAmount(Token amount) { + this.amount = amount; + } + + public long getExpireTime() { + return expireTime; + } + + public void setExpireTime(long expireTime) { + this.expireTime = expireTime; + } + + @Override + public String toString() { + return "TransferOut{" + + "from='" + from + '\'' + + ", toAddress='" + toAddress + '\'' + + ", amount=" + amount + + ", expireTime=" + expireTime + + '}'; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java b/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java index ca50fdd..e3d6576 100644 --- a/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java +++ b/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java @@ -22,5 +22,13 @@ public enum TxType { HTL_TRANSFER, CLAIM_HTL, REFUND_HTL, - DEPOSIT_HTL + DEPOSIT_HTL, + CREATE_SIDECHAIN_VALIDATOR, + EDIT_SIDECHAIN_VALIDATOR, + SIDECHAIN_DELEGATE, + SIDECHAIN_REDELEGATE, + SIDECHAIN_UNBOND, + CLAIM, + TRANSFER_OUT, + BIND } diff --git a/src/main/java/com/binance/dex/api/client/domain/oracle/ClaimMsg.java b/src/main/java/com/binance/dex/api/client/domain/oracle/ClaimMsg.java new file mode 100644 index 0000000..0774a3f --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/oracle/ClaimMsg.java @@ -0,0 +1,57 @@ +package com.binance.dex.api.client.domain.oracle; + +/** + * @author Fitz.Lu + **/ +public class ClaimMsg { + + private int claimType; + + private long sequence; + + private String claim; + + private String validatorAddress; + + public int getClaimType() { + return claimType; + } + + public void setClaimType(int claimType) { + this.claimType = claimType; + } + + public long getSequence() { + return sequence; + } + + public void setSequence(long sequence) { + this.sequence = sequence; + } + + public String getClaim() { + return claim; + } + + public void setClaim(String claim) { + this.claim = claim; + } + + public String getValidatorAddress() { + return validatorAddress; + } + + public void setValidatorAddress(String validatorAddress) { + this.validatorAddress = validatorAddress; + } + + @Override + public String toString() { + return "ClaimMsg{" + + "claimType=" + claimType + + ", sequence=" + sequence + + ", claim='" + claim + '\'' + + ", validatorAddress='" + validatorAddress + '\'' + + '}'; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/oracle/Prophecy.java b/src/main/java/com/binance/dex/api/client/domain/oracle/Prophecy.java new file mode 100644 index 0000000..c7ca9f1 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/oracle/Prophecy.java @@ -0,0 +1,59 @@ +package com.binance.dex.api.client.domain.oracle; + +import java.util.Map; + +/** + * @author Fitz.Lu + **/ +public class Prophecy { + + private String id; + + private Status status; + + private Map claimValidators; + + private Map validatorClaims; + + public Prophecy() { + } + + public Prophecy(String id, Status status, Map claimValidators, Map validatorClaims) { + this.id = id; + this.status = status; + this.claimValidators = claimValidators; + this.validatorClaims = validatorClaims; + } + + public String getId() { + return id; + } + + public void setId(String id) { + this.id = id; + } + + public Status getStatus() { + return status; + } + + public void setStatus(Status status) { + this.status = status; + } + + public Map getClaimValidators() { + return claimValidators; + } + + public void setClaimValidators(Map claimValidators) { + this.claimValidators = claimValidators; + } + + public Map getValidatorClaims() { + return validatorClaims; + } + + public void setValidatorClaims(Map validatorClaims) { + this.validatorClaims = validatorClaims; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/oracle/Status.java b/src/main/java/com/binance/dex/api/client/domain/oracle/Status.java new file mode 100644 index 0000000..450e457 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/oracle/Status.java @@ -0,0 +1,35 @@ +package com.binance.dex.api.client.domain.oracle; + +/** + * @author Fitz.Lu + **/ +public class Status { + + private int text; + + private String finalClaim; + + public Status() { + } + + public Status(int text, String finalClaim) { + this.text = text; + this.finalClaim = finalClaim; + } + + public int getText() { + return text; + } + + public void setText(int text) { + this.text = text; + } + + public String getFinalClaim() { + return finalClaim; + } + + public void setFinalClaim(String finalClaim) { + this.finalClaim = finalClaim; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/sidechain/Commission.java b/src/main/java/com/binance/dex/api/client/domain/stake/Commission.java similarity index 96% rename from src/main/java/com/binance/dex/api/client/domain/sidechain/Commission.java rename to src/main/java/com/binance/dex/api/client/domain/stake/Commission.java index 629aa6e..9b76af8 100644 --- a/src/main/java/com/binance/dex/api/client/domain/sidechain/Commission.java +++ b/src/main/java/com/binance/dex/api/client/domain/stake/Commission.java @@ -1,4 +1,4 @@ -package com.binance.dex.api.client.domain.sidechain; +package com.binance.dex.api.client.domain.stake; /** * @author Fitz.Lu diff --git a/src/main/java/com/binance/dex/api/client/domain/sidechain/Description.java b/src/main/java/com/binance/dex/api/client/domain/stake/Description.java similarity index 96% rename from src/main/java/com/binance/dex/api/client/domain/sidechain/Description.java rename to src/main/java/com/binance/dex/api/client/domain/stake/Description.java index 0bab14e..d5f4562 100644 --- a/src/main/java/com/binance/dex/api/client/domain/sidechain/Description.java +++ b/src/main/java/com/binance/dex/api/client/domain/stake/Description.java @@ -1,4 +1,4 @@ -package com.binance.dex.api.client.domain.sidechain; +package com.binance.dex.api.client.domain.stake; /** * @author Fitz.Lu diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/Pool.java b/src/main/java/com/binance/dex/api/client/domain/stake/Pool.java new file mode 100644 index 0000000..9113240 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/stake/Pool.java @@ -0,0 +1,38 @@ +package com.binance.dex.api.client.domain.stake; + +/** + * @author Fitz.Lu + **/ +public class Pool { + + private long looseTokens; + + private long bondedTokens; + + public Pool() { + } + + public long getLooseTokens() { + return looseTokens; + } + + public void setLooseTokens(long looseTokens) { + this.looseTokens = looseTokens; + } + + public long getBondedTokens() { + return bondedTokens; + } + + public void setBondedTokens(long bondedTokens) { + this.bondedTokens = bondedTokens; + } + + @Override + public String toString() { + return "Pool{" + + "looseTokens=" + looseTokens + + ", bondedTokens=" + bondedTokens + + '}'; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/sidechain/CreateSideChainValidator.java b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/CreateSideChainValidator.java similarity index 61% rename from src/main/java/com/binance/dex/api/client/domain/sidechain/CreateSideChainValidator.java rename to src/main/java/com/binance/dex/api/client/domain/stake/sidechain/CreateSideChainValidator.java index 33c717a..2f35a2e 100644 --- a/src/main/java/com/binance/dex/api/client/domain/sidechain/CreateSideChainValidator.java +++ b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/CreateSideChainValidator.java @@ -1,5 +1,7 @@ -package com.binance.dex.api.client.domain.sidechain; +package com.binance.dex.api.client.domain.stake.sidechain; +import com.binance.dex.api.client.domain.stake.Commission; +import com.binance.dex.api.client.domain.stake.Description; import com.binance.dex.api.client.encoding.message.Token; /** @@ -13,6 +15,8 @@ public class CreateSideChainValidator { private String delegatorAddr; + private String validatorAddr; + private Token delegation; private String sideChainId; @@ -79,4 +83,26 @@ public String getSideFeeAddr() { public void setSideFeeAddr(String sideFeeAddr) { this.sideFeeAddr = sideFeeAddr; } + + public String getValidatorAddr() { + return validatorAddr; + } + + public void setValidatorAddr(String validatorAddr) { + this.validatorAddr = validatorAddr; + } + + @Override + public String toString() { + return "CreateSideChainValidator{" + '\n' + + "description=" + description + '\n' + + ", commission=" + commission + '\n' + + ", delegatorAddr='" + delegatorAddr + '\'' + '\n' + + ", validatorAddr='" + validatorAddr + '\'' + '\n' + + ", delegation=" + delegation + '\n' + + ", sideChainId='" + sideChainId + '\'' + '\n' + + ", sideConsAddr='" + sideConsAddr + '\'' + '\n' + + ", sideFeeAddr='" + sideFeeAddr + '\'' + '\n' + + '}'; + } } diff --git a/src/main/java/com/binance/dex/api/client/domain/sidechain/EditSideChainValidator.java b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/EditSideChainValidator.java similarity index 55% rename from src/main/java/com/binance/dex/api/client/domain/sidechain/EditSideChainValidator.java rename to src/main/java/com/binance/dex/api/client/domain/stake/sidechain/EditSideChainValidator.java index 88361be..f06051c 100644 --- a/src/main/java/com/binance/dex/api/client/domain/sidechain/EditSideChainValidator.java +++ b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/EditSideChainValidator.java @@ -1,4 +1,6 @@ -package com.binance.dex.api.client.domain.sidechain; +package com.binance.dex.api.client.domain.stake.sidechain; + +import com.binance.dex.api.client.domain.stake.Description; /** * @author Fitz.Lu @@ -7,12 +9,12 @@ public class EditSideChainValidator { private Description description; + private String validatorAddress; + private long commissionRate; private String sideChainId; - private String sideConsAddr; - private String sideFeeAddr; public EditSideChainValidator() { @@ -26,6 +28,14 @@ public void setDescription(Description description) { this.description = description; } + public String getValidatorAddress() { + return validatorAddress; + } + + public void setValidatorAddress(String validatorAddress) { + this.validatorAddress = validatorAddress; + } + public long getCommissionRate() { return commissionRate; } @@ -42,14 +52,6 @@ public void setSideChainId(String sideChainId) { this.sideChainId = sideChainId; } - public String getSideConsAddr() { - return sideConsAddr; - } - - public void setSideConsAddr(String sideConsAddr) { - this.sideConsAddr = sideConsAddr; - } - public String getSideFeeAddr() { return sideFeeAddr; } @@ -57,4 +59,15 @@ public String getSideFeeAddr() { public void setSideFeeAddr(String sideFeeAddr) { this.sideFeeAddr = sideFeeAddr; } + + @Override + public String toString() { + return "EditSideChainValidator{" + + "description=" + description + "\n" + + ", validatorAddress='" + validatorAddress + '\'' + "\n" + + ", commissionRate=" + commissionRate + "\n" + + ", sideChainId='" + sideChainId + '\'' + "\n" + + ", sideFeeAddr='" + sideFeeAddr + '\'' + "\n" + + '}'; + } } diff --git a/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainDelegate.java b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainDelegate.java similarity index 76% rename from src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainDelegate.java rename to src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainDelegate.java index 62335c9..a9045f6 100644 --- a/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainDelegate.java +++ b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainDelegate.java @@ -1,4 +1,4 @@ -package com.binance.dex.api.client.domain.sidechain; +package com.binance.dex.api.client.domain.stake.sidechain; import com.binance.dex.api.client.encoding.message.Token; @@ -56,4 +56,14 @@ public String getSideChainId() { public void setSideChainId(String sideChainId) { this.sideChainId = sideChainId; } + + @Override + public String toString() { + return "SideChainDelegate{" + + "delegatorAddress='" + delegatorAddress + '\'' + + ", validatorAddress='" + validatorAddress + '\'' + + ", delegation=" + delegation + + ", sideChainId='" + sideChainId + '\'' + + '}'; + } } diff --git a/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainDelegation.java b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainDelegation.java similarity index 65% rename from src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainDelegation.java rename to src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainDelegation.java index 411777e..b4e5b4b 100644 --- a/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainDelegation.java +++ b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainDelegation.java @@ -1,4 +1,4 @@ -package com.binance.dex.api.client.domain.sidechain; +package com.binance.dex.api.client.domain.stake.sidechain; import java.util.Arrays; @@ -7,9 +7,9 @@ **/ public class SideChainDelegation { - private byte[] delegatorAddress; + private String delegatorAddress; - private byte[] validatorAddress; + private String validatorAddress; private long shares; @@ -18,26 +18,26 @@ public class SideChainDelegation { public SideChainDelegation() { } - public SideChainDelegation(byte[] delegatorAddress, byte[] validatorAddress, long shares, long height) { + public SideChainDelegation(String delegatorAddress, String validatorAddress, long shares, long height) { this.delegatorAddress = delegatorAddress; this.validatorAddress = validatorAddress; this.shares = shares; this.height = height; } - public byte[] getDelegatorAddress() { + public String getDelegatorAddress() { return delegatorAddress; } - public void setDelegatorAddress(byte[] delegatorAddress) { + public void setDelegatorAddress(String delegatorAddress) { this.delegatorAddress = delegatorAddress; } - public byte[] getValidatorAddress() { + public String getValidatorAddress() { return validatorAddress; } - public void setValidatorAddress(byte[] validatorAddress) { + public void setValidatorAddress(String validatorAddress) { this.validatorAddress = validatorAddress; } @@ -60,8 +60,8 @@ public void setHeight(long height) { @Override public String toString() { return "SideChainDelegation{" + - "delegatorAddress=" + Arrays.toString(delegatorAddress) + - ", validatorAddress=" + Arrays.toString(validatorAddress) + + "delegatorAddress=" + delegatorAddress + + ", validatorAddress=" + validatorAddress + ", shares=" + shares + ", height=" + height + '}'; diff --git a/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainRedelegate.java b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainRedelegate.java similarity index 73% rename from src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainRedelegate.java rename to src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainRedelegate.java index 1aedeeb..329a7fa 100644 --- a/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainRedelegate.java +++ b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainRedelegate.java @@ -1,4 +1,4 @@ -package com.binance.dex.api.client.domain.sidechain; +package com.binance.dex.api.client.domain.stake.sidechain; import com.binance.dex.api.client.encoding.message.Token; @@ -59,4 +59,15 @@ public String getSideChainId() { public void setSideChainId(String sideChainId) { this.sideChainId = sideChainId; } + + @Override + public String toString() { + return "SideChainRedelegate{" + + "delegatorAddress='" + delegatorAddress + '\'' + + ", srcValidatorAddress='" + srcValidatorAddress + '\'' + + ", dstValidatorAddress='" + dstValidatorAddress + '\'' + + ", amount=" + amount + + ", sideChainId='" + sideChainId + '\'' + + '}'; + } } diff --git a/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainRedelegation.java b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainRedelegation.java similarity index 59% rename from src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainRedelegation.java rename to src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainRedelegation.java index 366cb39..94bd09e 100644 --- a/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainRedelegation.java +++ b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainRedelegation.java @@ -1,4 +1,4 @@ -package com.binance.dex.api.client.domain.sidechain; +package com.binance.dex.api.client.domain.stake.sidechain; import com.binance.dex.api.client.encoding.message.Token; @@ -9,18 +9,20 @@ public class SideChainRedelegation { //delegator address - private byte[] delegatorAddress; + private String delegatorAddress; //validator redelegation source operator address - private byte[] srcValidatorAddress; + private String srcValidatorAddress; //validator redelegation destination operator address - private byte[] dstValidatorAddress; + private String dstValidatorAddress; //height which the redelegation took place private long createHeight; //unix time for redelegation completion + private String minTime; + private long minTimeInMs; //initial balance when redelegation started @@ -35,27 +37,30 @@ public class SideChainRedelegation { //amount of destination shares redelegating private long dstShare; - public byte[] getDelegatorAddress() { + public SideChainRedelegation() { + } + + public String getDelegatorAddress() { return delegatorAddress; } - public void setDelegatorAddress(byte[] delegatorAddress) { + public void setDelegatorAddress(String delegatorAddress) { this.delegatorAddress = delegatorAddress; } - public byte[] getSrcValidatorAddress() { + public String getSrcValidatorAddress() { return srcValidatorAddress; } - public void setSrcValidatorAddress(byte[] srcValidatorAddress) { + public void setSrcValidatorAddress(String srcValidatorAddress) { this.srcValidatorAddress = srcValidatorAddress; } - public byte[] getDstValidatorAddress() { + public String getDstValidatorAddress() { return dstValidatorAddress; } - public void setDstValidatorAddress(byte[] dstValidatorAddress) { + public void setDstValidatorAddress(String dstValidatorAddress) { this.dstValidatorAddress = dstValidatorAddress; } @@ -67,6 +72,14 @@ public void setCreateHeight(long createHeight) { this.createHeight = createHeight; } + public String getMinTime() { + return minTime; + } + + public void setMinTime(String minTime) { + this.minTime = minTime; + } + public long getMinTimeInMs() { return minTimeInMs; } @@ -106,4 +119,20 @@ public long getDstShare() { public void setDstShare(long dstShare) { this.dstShare = dstShare; } + + @Override + public String toString() { + return "SideChainRedelegation{" + + "delegatorAddress='" + delegatorAddress + '\'' + + ", srcValidatorAddress='" + srcValidatorAddress + '\'' + + ", dstValidatorAddress='" + dstValidatorAddress + '\'' + + ", createHeight=" + createHeight + + ", minTime='" + minTime + '\'' + + ", minTimeInMs=" + minTimeInMs + + ", initialBalance=" + initialBalance + + ", balance=" + balance + + ", srcShares=" + srcShares + + ", dstShare=" + dstShare + + '}'; + } } diff --git a/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainUnBond.java b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainUnBond.java similarity index 71% rename from src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainUnBond.java rename to src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainUnBond.java index 583bf06..18922f3 100644 --- a/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainUnBond.java +++ b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainUnBond.java @@ -1,4 +1,4 @@ -package com.binance.dex.api.client.domain.sidechain; +package com.binance.dex.api.client.domain.stake.sidechain; import com.binance.dex.api.client.encoding.message.Token; @@ -49,4 +49,14 @@ public String getSideChainId() { public void setSideChainId(String sideChainId) { this.sideChainId = sideChainId; } + + @Override + public String toString() { + return "SideChainUnBond{" + + "delegatorAddress='" + delegatorAddress + '\'' + + ", validatorAddress='" + validatorAddress + '\'' + + ", amount=" + amount + + ", sideChainId='" + sideChainId + '\'' + + '}'; + } } diff --git a/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainValidator.java b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainValidator.java similarity index 76% rename from src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainValidator.java rename to src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainValidator.java index f0eef18..c691268 100644 --- a/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainValidator.java +++ b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainValidator.java @@ -1,4 +1,7 @@ -package com.binance.dex.api.client.domain.sidechain; +package com.binance.dex.api.client.domain.stake.sidechain; + +import com.binance.dex.api.client.domain.stake.Commission; +import com.binance.dex.api.client.domain.stake.Description; import java.util.Arrays; @@ -7,9 +10,9 @@ **/ public class SideChainValidator { - private byte[] feeAddr; + private String feeAddr; - private byte[] operatorAddr; + private String operatorAddr; private byte[] consPubKey; @@ -33,30 +36,30 @@ public class SideChainValidator { private Commission commission; - private byte[] distributionAddr; + private String distributionAddr; private String sideChainId; - private byte[] sideConsAddr; + private String sideConsAddr; - private byte[] sideFeeAddr; + private String sideFeeAddr; public SideChainValidator() { } - public byte[] getFeeAddr() { + public String getFeeAddr() { return feeAddr; } - public void setFeeAddr(byte[] feeAddr) { + public void setFeeAddr(String feeAddr) { this.feeAddr = feeAddr; } - public byte[] getOperatorAddr() { + public String getOperatorAddr() { return operatorAddr; } - public void setOperatorAddr(byte[] operatorAddr) { + public void setOperatorAddr(String operatorAddr) { this.operatorAddr = operatorAddr; } @@ -148,12 +151,12 @@ public void setCommission(Commission commission) { this.commission = commission; } - public byte[] getDistributionAddr() { + public String getDistributionAddr() { return distributionAddr; } - public void setDistributionAddr(byte[] distributionAddr) { - distributionAddr = distributionAddr; + public void setDistributionAddr(String distributionAddr) { + this.distributionAddr = distributionAddr; } public String getSideChainId() { @@ -164,27 +167,27 @@ public void setSideChainId(String sideChainId) { this.sideChainId = sideChainId; } - public byte[] getSideConsAddr() { + public String getSideConsAddr() { return sideConsAddr; } - public void setSideConsAddr(byte[] sideConsAddr) { + public void setSideConsAddr(String sideConsAddr) { this.sideConsAddr = sideConsAddr; } - public byte[] getSideFeeAddr() { + public String getSideFeeAddr() { return sideFeeAddr; } - public void setSideFeeAddr(byte[] sideFeeAddr) { + public void setSideFeeAddr(String sideFeeAddr) { this.sideFeeAddr = sideFeeAddr; } @Override public String toString() { return "SideChainValidator{" + - "feeAddr=" + Arrays.toString(feeAddr) + '\n' + - ", operatorAddr=" + Arrays.toString(operatorAddr) + '\n' + + "feeAddr=" + feeAddr + '\n' + + ", operatorAddr=" + operatorAddr + '\n' + ", consPubKey='" + consPubKey + '\'' + '\n' + ", jailed=" + jailed + '\n' + ", status=" + status + '\n' + @@ -196,10 +199,10 @@ public String toString() { ", unBondingHeight=" + unBondingHeight + '\n' + ", unBondingMinTime=" + unBondingMinTime + '\n' + ", commission=" + commission + '\n' + - ", distributionAddr=" + Arrays.toString(distributionAddr) + '\n' + + ", distributionAddr=" + distributionAddr + '\n' + ", sideChainId='" + sideChainId + '\'' + '\n' + - ", sideConsAddr=" + Arrays.toString(sideConsAddr) + '\n' + - ", sideFeeAddr=" + Arrays.toString(sideFeeAddr) + '\n' + + ", sideConsAddr=" + sideConsAddr + '\n' + + ", sideFeeAddr=" + sideFeeAddr + '\n' + '}'; } diff --git a/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainUnBondingDelegation.java b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/UnBondingDelegation.java similarity index 63% rename from src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainUnBondingDelegation.java rename to src/main/java/com/binance/dex/api/client/domain/stake/sidechain/UnBondingDelegation.java index 6b85ece..b7ba0f8 100644 --- a/src/main/java/com/binance/dex/api/client/domain/sidechain/SideChainUnBondingDelegation.java +++ b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/UnBondingDelegation.java @@ -1,39 +1,39 @@ -package com.binance.dex.api.client.domain.sidechain; +package com.binance.dex.api.client.domain.stake.sidechain; import com.binance.dex.api.client.encoding.message.Token; -import java.util.Arrays; - /** * @author Fitz.Lu **/ -public class SideChainUnBondingDelegation { +public class UnBondingDelegation { - private byte[] delegatorAddress; + private String delegatorAddress; - private byte[] validatorAddress; + private String validatorAddress; private long createHeight; private long minTimeInMs; + private String minTime; + private Token initialBalance; private Token balance; - public byte[] getDelegatorAddress() { + public String getDelegatorAddress() { return delegatorAddress; } - public void setDelegatorAddress(byte[] delegatorAddress) { + public void setDelegatorAddress(String delegatorAddress) { this.delegatorAddress = delegatorAddress; } - public byte[] getValidatorAddress() { + public String getValidatorAddress() { return validatorAddress; } - public void setValidatorAddress(byte[] validatorAddress) { + public void setValidatorAddress(String validatorAddress) { this.validatorAddress = validatorAddress; } @@ -53,6 +53,14 @@ public void setMinTimeInMs(long minTimeInMs) { this.minTimeInMs = minTimeInMs; } + public String getMinTime() { + return minTime; + } + + public void setMinTime(String minTime) { + this.minTime = minTime; + } + public Token getInitialBalance() { return initialBalance; } @@ -71,11 +79,12 @@ public void setBalance(Token balance) { @Override public String toString() { - return "SideChainUnBondingDelegation{" + - "delegatorAddress=" + Arrays.toString(delegatorAddress) + - ", validatorAddress=" + Arrays.toString(validatorAddress) + + return "UnBondingDelegation{" + + "delegatorAddress='" + delegatorAddress + '\'' + + ", validatorAddress='" + validatorAddress + '\'' + ", createHeight=" + createHeight + ", minTimeInMs=" + minTimeInMs + + ", minTime='" + minTime + '\'' + ", initialBalance=" + initialBalance + ", balance=" + balance + '}'; diff --git a/src/main/java/com/binance/dex/api/client/encoding/Crypto.java b/src/main/java/com/binance/dex/api/client/encoding/Crypto.java index 1e69709..7e9f426 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/Crypto.java +++ b/src/main/java/com/binance/dex/api/client/encoding/Crypto.java @@ -5,6 +5,7 @@ import org.bitcoinj.core.Sha256Hash; import org.bitcoinj.core.Utils; import org.bitcoinj.crypto.*; +import org.bouncycastle.util.encoders.Hex; import java.io.ByteArrayOutputStream; import java.io.IOException; @@ -183,4 +184,17 @@ public static class SegwitAddressException extends IllegalArgumentException { super(s); } } + + public static String encodeEthAddress(byte[] address){ + return "0x" + Hex.toHexString(address); + } + + public static byte[] decodeEthAddress(String address){ + String addr = address; + if (addr.startsWith("0x")){ + addr = address.substring(2); + } + return Hex.decode(addr); + } + } diff --git a/src/main/java/com/binance/dex/api/client/encoding/amino/Amino.java b/src/main/java/com/binance/dex/api/client/encoding/amino/Amino.java index 024258b..5e66f4c 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/amino/Amino.java +++ b/src/main/java/com/binance/dex/api/client/encoding/amino/Amino.java @@ -34,7 +34,7 @@ public class Amino { * * @param name the name */ - public byte[] nameToDisamb(String name){ + public byte[] nameToDisamb(String name) throws NoSuchAlgorithmException { return nameToDisambPrefix(name).getDisamb(); } @@ -43,11 +43,11 @@ public byte[] nameToDisamb(String name){ * * @param name the name */ - public byte[] nameToPrefix(String name) { + public byte[] nameToPrefix(String name) throws NoSuchAlgorithmException { return nameToDisambPrefix(name).getPrefix(); } - public String nameToPrefixString(String name) { + public String nameToPrefixString(String name) throws NoSuchAlgorithmException { return Hex.toHexString(nameToDisambPrefix(name).getPrefix()); } @@ -57,14 +57,10 @@ public String nameToPrefixString(String name) { * @param name the name * @see DisambPrefix */ - public DisambPrefix nameToDisambPrefix(String name) { + public DisambPrefix nameToDisambPrefix(String name) throws NoSuchAlgorithmException { DisambPrefix disambPrefix = new DisambPrefix(); byte[] nameHash = new byte[0]; - try { - nameHash = dropLeadingZero(AminoHashing.sha256(name)); - } catch (NoSuchAlgorithmException e) { - e.printStackTrace(); - } + nameHash = dropLeadingZero(AminoHashing.sha256(name)); disambPrefix.setDisamb(Arrays.copyOfRange(nameHash, 0, disambiguationByteSize)); byte[] rest = Arrays.copyOfRange(nameHash, disambiguationByteSize, nameHash.length); @@ -162,6 +158,12 @@ private void encodeAminoMessageBare(AminoSerializable message, CodedOutputStream if (field.getT() instanceof Long){ encodeInt64(index, ((Long) field.getT()), outputStream); + continue; + } + + if (field.getT() instanceof Integer){ + encodeInt32(index, (Integer) field.getT(), outputStream); + continue; } } } @@ -315,6 +317,11 @@ private void encodeInt64(int fieldIndex, long value, CodedOutputStream outputStr outputStream.writeInt64NoTag(value); } + private void encodeInt32(int fieldIndex, int value, CodedOutputStream outputStream) throws IOException { + outputStream.writeTag(fieldIndex, WireType.VARINT); + outputStream.writeInt32NoTag(value); + } + private void encodeUInt32Bare(int value, CodedOutputStream codedOutputStream) throws IOException { codedOutputStream.writeUInt32NoTag(value); } @@ -362,6 +369,13 @@ public int computeSerializedSize(AminoSerializable message){ if (iterateField.getT() instanceof Long){ size += computeTagSize(index, WireType.VARINT); size += computeInt64Size(((Long) iterateField.getT())); + continue; + } + + if (iterateField.getT() instanceof Integer){ + size += computeTagSize(index, WireType.VARINT); + size += computeInt32Size((Integer) iterateField.getT()); + continue; } } diff --git a/src/main/java/com/binance/dex/api/client/encoding/amino/InternalAmino.java b/src/main/java/com/binance/dex/api/client/encoding/amino/InternalAmino.java new file mode 100644 index 0000000..9169e84 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/amino/InternalAmino.java @@ -0,0 +1,14 @@ +package com.binance.dex.api.client.encoding.amino; + +/** + * @author Fitz.Lu + **/ +class InternalAmino { + + static final Amino ins = new Amino(); + + static Amino get(){ + return ins; + } + +} \ No newline at end of file diff --git a/src/main/java/com/binance/dex/api/client/encoding/amino/WireType.java b/src/main/java/com/binance/dex/api/client/encoding/amino/WireType.java index 6cc466f..da61b1a 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/amino/WireType.java +++ b/src/main/java/com/binance/dex/api/client/encoding/amino/WireType.java @@ -1,11 +1,14 @@ package com.binance.dex.api.client.encoding.amino; import com.binance.dex.api.client.encoding.amino.types.PubKeyEd25519; +import com.binance.dex.api.client.encoding.message.bridge.BindMsgMessage; +import com.binance.dex.api.client.encoding.message.bridge.ClaimMsgMessage; +import com.binance.dex.api.client.encoding.message.bridge.TransferOutMsgMessage; import com.binance.dex.api.client.encoding.message.sidechain.transaction.*; import org.bouncycastle.util.encoders.Hex; +import java.security.NoSuchAlgorithmException; import java.util.HashMap; -import java.util.Map; /** * @author Fitz.Lu @@ -13,23 +16,20 @@ **/ public class WireType { - private static final HashMap, String> aminoType; - private static final HashMap> typePrefixMap; + private static final HashMap, String> classToTypeName = new HashMap<>(); static { - aminoType = new HashMap<>(); - aminoType.put(PubKeyEd25519.class, "tendermint/PubKeyEd25519"); - aminoType.put(CreateSideChainValidatorMessage.class, "cosmos-sdk/MsgCreateSideChainValidator"); - aminoType.put(EditSideChainValidatorMessage.class, "cosmos-sdk/MsgEditSideChainValidator"); - aminoType.put(SideChainDelegateMessage.class, "cosmos-sdk/MsgSideChainDelegate"); - aminoType.put(SideChainRedelegateMessage.class, "cosmos-sdk/MsgSideChainRedelegate"); - aminoType.put(SideChainUndelegateMessage.class, "cosmos-sdk/MsgSideChainUndelegate"); - - typePrefixMap = new HashMap<>(); - Amino amino = new Amino(); - for (Map.Entry, String> entry : aminoType.entrySet()) { - typePrefixMap.put(amino.nameToPrefixString(entry.getValue()), entry.getKey()); - } + classToTypeName.put(PubKeyEd25519.class, "tendermint/PubKeyEd25519"); + + classToTypeName.put(CreateSideChainValidatorMessage.class, "cosmos-sdk/MsgCreateSideChainValidator"); + classToTypeName.put(EditSideChainValidatorMessage.class, "cosmos-sdk/MsgEditSideChainValidator"); + classToTypeName.put(SideChainDelegateMessage.class, "cosmos-sdk/MsgSideChainDelegate"); + classToTypeName.put(SideChainRedelegateMessage.class, "cosmos-sdk/MsgSideChainRedelegate"); + classToTypeName.put(SideChainUndelegateMessage.class, "cosmos-sdk/MsgSideChainUndelegate"); + + classToTypeName.put(TransferOutMsgMessage.class, "bridge/TransferOutMsg"); + classToTypeName.put(BindMsgMessage.class, "bridge/BindMsg"); + classToTypeName.put(ClaimMsgMessage.class, "oracle/ClaimMsg"); } public static int VARINT = 0; //int32, int64, uint32, uint64, sint32, sint64, bool, enum @@ -40,16 +40,31 @@ public class WireType { public static int BIT_32 = 5; // fixed32, sfixed32, float + public static boolean isRegistered(Class clazz){ - return aminoType.containsKey(clazz); + return classToTypeName.containsKey(clazz); } public static boolean isRegistered(byte[] typePrefix){ - return typePrefixMap.containsKey(Hex.toHexString(typePrefix)); + String typeHex = Hex.toHexString(typePrefix); + for (String value : classToTypeName.values()) { + if (typeHex.equals(value)){ + return true; + } + } + + return false; + } + + public static String getRegisteredTypeName(Class clazz) { + return classToTypeName.get(clazz); } - public static String getRegisteredTypeName(Class clazz){ - return aminoType.get(clazz); + public static byte[] getTypePrefix(Class clazz) throws IllegalStateException, NoSuchAlgorithmException { + if (!isRegistered(clazz)){ + throw new IllegalStateException("class " + clazz.getCanonicalName() + " has not been registered into amino"); + } + return InternalAmino.get().nameToPrefix(getRegisteredTypeName(clazz)); } } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/BinanceDexTransactionMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/BinanceDexTransactionMessage.java index d293be0..ea31b31 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/BinanceDexTransactionMessage.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/BinanceDexTransactionMessage.java @@ -1,4 +1,11 @@ package com.binance.dex.api.client.encoding.message; public interface BinanceDexTransactionMessage { + + default boolean useAminoJson(){ + return false; + } + + default void validateBasic(){} + } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java b/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java index 29a24db..a37bf2c 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java @@ -37,7 +37,10 @@ public enum MessageType { EditSideChainValidator("264CC57B"), SideChainDelegate("E3A07FD2"), SideChainRedelegate("E3CED364"), - SideChainUndelegate("514F7E0E"); + SideChainUndelegate("514F7E0E"), + Claim("175A0521"), + TransferOut("800819C0"), + Bind("B9AE640C"); private byte[] typePrefixBytes; MessageType(String typePrefix) { diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/Token.java b/src/main/java/com/binance/dex/api/client/encoding/message/Token.java index 8448f41..39df5c2 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/Token.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/Token.java @@ -10,7 +10,9 @@ @JsonIgnoreProperties(ignoreUnknown = true) @JsonPropertyOrder(alphabetic = true) public class Token { + @JsonProperty(value = "denom") private String denom; + @JsonProperty(value = "amount") private Long amount; public static Token of(com.binance.dex.api.proto.Token source) { diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/TransactionRequestAssembler.java b/src/main/java/com/binance/dex/api/client/encoding/message/TransactionRequestAssembler.java index 073a23a..290f4b4 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/TransactionRequestAssembler.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/TransactionRequestAssembler.java @@ -2,14 +2,11 @@ import com.binance.dex.api.client.Wallet; import com.binance.dex.api.client.domain.broadcast.*; -import com.binance.dex.api.client.domain.sidechain.*; import com.binance.dex.api.client.encoding.Crypto; import com.binance.dex.api.client.encoding.EncodeUtils; import com.binance.dex.api.client.encoding.amino.Amino; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; import com.binance.dex.api.client.encoding.amino.WireType; -import com.binance.dex.api.client.encoding.message.sidechain.SideChainClassConverter; -import com.binance.dex.api.client.encoding.message.sidechain.transaction.*; -import com.binance.dex.api.client.encoding.message.sidechain.value.*; import com.binance.dex.api.proto.StdSignature; import com.binance.dex.api.proto.StdTx; import com.google.common.annotations.VisibleForTesting; @@ -60,18 +57,18 @@ public static String longToDouble(long l) { @VisibleForTesting byte[] signTx(BinanceDexTransactionMessage msg) throws IOException, NoSuchAlgorithmException { - return sign(assembleMessage4Sigh(msg)); + return sign(assembleMessage4Sign(msg)); } - private BinanceDexTransactionMessage assembleMessage4Sigh(T t){ - if (WireType.isRegistered(t.getClass())){ - return new TransactionMessageWithType(WireType.getRegisteredTypeName(t.getClass()), t); - }else{ - if (!BinanceDexTransactionMessage.class.isAssignableFrom(t.getClass())){ - throw new IllegalStateException("sign message should implement BinanceDexTransactionMessage"); + private BinanceDexTransactionMessage assembleMessage4Sign(T t){ + if (t.useAminoJson()){ + if (WireType.isRegistered(t.getClass())){ + return new TransactionMessageWithType(WireType.getRegisteredTypeName(t.getClass()), t); }else{ - return ((BinanceDexTransactionMessage) t); + throw new IllegalStateException("Class " + t.getClass().getCanonicalName() + " has not been registered into amino"); } + }else{ + return t; } } @@ -91,7 +88,6 @@ byte[] sign(BinanceDexTransactionMessage msg) return Crypto.sign(EncodeUtils.toJsonEncodeBytes(sd), wallet.getLedgerKey()); } - String d = new String(EncodeUtils.toJsonEncodeBytes(sd)); return Crypto.sign(EncodeUtils.toJsonEncodeBytes(sd), wallet.getEcKey()); } @@ -579,103 +575,19 @@ public byte[] encodeRefundHtltMessage(RefundHtltMessage msg) throws IOException return EncodeUtils.aminoWrap(proto.toByteArray(), MessageType.RefundHashTimerLockMsg.getTypePrefixBytes(), false); } - @VisibleForTesting - CreateSideChainValidatorMessage createSideChainValidatorMessage(CreateSideChainValidator createSideChainValidator){ - CreateSideChainValidatorMessage message = new CreateSideChainValidatorMessage(); - - if (createSideChainValidator.getDescription() != null){ - message.setDescription(SideChainClassConverter.convert(createSideChainValidator.getDescription())); + /** + * Used for amino serializable message + * */ + public String buildTxPayload(BinanceDexTransactionMessage message) throws IOException, NoSuchAlgorithmException { + if (!AminoSerializable.class.isAssignableFrom(message.getClass())){ + throw new IllegalArgumentException("Class " + message.getClass() + " should also implement AminoSerializable to support amino encoding"); } - if (createSideChainValidator.getCommission() != null){ - message.setCommission(SideChainClassConverter.convert(createSideChainValidator.getCommission())); - } - - message.setDelegatorAddr(AddressValue.from(createSideChainValidator.getDelegatorAddr())); - if (createSideChainValidator.getDelegation() != null){ - message.setDelegation(SideChainClassConverter.convert(createSideChainValidator.getDelegation())); - } - - message.setSideChainId(createSideChainValidator.getSideChainId()); - message.setSideConsAddr(decodeHexAddress(createSideChainValidator.getSideConsAddr())); - message.setSideFeeAddr(decodeHexAddress(createSideChainValidator.getSideFeeAddr())); - return message; - } - - @VisibleForTesting - byte[] encodeCreateSideChainValidatorMessage(CreateSideChainValidatorMessage message) throws IOException { - return amino.encode(message, MessageType.CreateSideChainValidator.getTypePrefixBytes(), false); - } - - @VisibleForTesting - public String buildCreateSideChainValidatorPayload(CreateSideChainValidator createSideChainValidator) throws IOException, NoSuchAlgorithmException { - CreateSideChainValidatorMessage message = createSideChainValidatorMessage(createSideChainValidator); - message.setValidatorOperatorAddr(AddressValue.from(wallet.getAddress())); - byte[] msg = encodeCreateSideChainValidatorMessage(message); + byte[] typePrefix = WireType.getTypePrefix(message.getClass()); + byte[] msg = amino.encode(((AminoSerializable) message), typePrefix, false); byte[] signature = encodeSignature(signTx(message)); byte[] stdTx = encodeStdTx(msg, signature); return EncodeUtils.bytesToHex(stdTx); } - @VisibleForTesting - EditSideChainValidatorMessage createEditSideChainValidatorMessage(EditSideChainValidator editSideChainValidator){ - EditSideChainValidatorMessage message = new EditSideChainValidatorMessage(); - - if (editSideChainValidator.getDescription() != null){ - message.setDescription(SideChainClassConverter.convert(editSideChainValidator.getDescription())); - } - - message.setCommissionRate(Dec.newInstance(editSideChainValidator.getCommissionRate())); - message.setSideChainId(editSideChainValidator.getSideChainId()); - message.setSideFeeAddr(decodeHexAddress(editSideChainValidator.getSideFeeAddr())); - - return message; - } - - @VisibleForTesting - byte[] encodeEditSideChainValidatorMessage(EditSideChainValidatorMessage message) throws IOException { - return amino.encode(message, MessageType.EditSideChainValidator.getTypePrefixBytes(), false); - } - - public String buildEditSideChainValidatorPayload(EditSideChainValidator editSideChainValidator) throws IOException, NoSuchAlgorithmException { - EditSideChainValidatorMessage message = createEditSideChainValidatorMessage(editSideChainValidator); - message.setValidatorOperatorAddress(AddressValue.from(wallet.getAddress())); - byte[] msg = encodeEditSideChainValidatorMessage(message); - byte[] signature = encodeSignature(signTx(message)); - byte[] stdTx = encodeStdTx(msg, signature); - return EncodeUtils.bytesToHex(stdTx); - } - - public String buildSideChainDelegatePayload(SideChainDelegate sideChainDelegate) throws IOException, NoSuchAlgorithmException { - SideChainDelegateMessage message = SideChainClassConverter.convert(sideChainDelegate); - byte[] msg = amino.encode(message, MessageType.SideChainDelegate.getTypePrefixBytes(), false); - byte[] signature = encodeSignature(signTx(message)); - byte[] stdTx = encodeStdTx(msg, signature); - return EncodeUtils.bytesToHex(stdTx); - } - - public String buildSideChainRedelegatePayload(SideChainRedelegate sideChainRedelegate) throws IOException, NoSuchAlgorithmException { - SideChainRedelegateMessage message = SideChainClassConverter.convert(sideChainRedelegate); - byte[] msg = amino.encode(message, MessageType.SideChainRedelegate.getTypePrefixBytes(), false); - byte[] signature = encodeSignature(signTx(message)); - byte[] stdTx = encodeStdTx(msg, signature); - return EncodeUtils.bytesToHex(stdTx); - } - - public String buildSideChainUndelegatePayload(SideChainUnBond sideChainUndelegate) throws IOException, NoSuchAlgorithmException { - SideChainUndelegateMessage message = SideChainClassConverter.convert(sideChainUndelegate); - byte[] msg = amino.encode(message, MessageType.SideChainUndelegate.getTypePrefixBytes(), false); - byte[] signature = encodeSignature(signTx(message)); - byte[] stdTx = encodeStdTx(msg, signature); - return EncodeUtils.bytesToHex(stdTx); - } - - private byte[] decodeHexAddress(String address){ - String addr = address; - if (addr.startsWith("0x")){ - addr = address.substring(2); - } - return Hex.decode(addr); - } - } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/BindMsgMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/BindMsgMessage.java new file mode 100644 index 0000000..0a3220b --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/BindMsgMessage.java @@ -0,0 +1,164 @@ +package com.binance.dex.api.client.encoding.message.bridge; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.encoding.message.common.EthAddressValue; +import com.binance.dex.api.client.encoding.serializer.Bech32AddressValueToStringSerializer; +import com.binance.dex.api.client.encoding.serializer.EthAddressValueToStringSerializer; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import org.apache.commons.lang3.StringUtils; + +import java.util.ArrayList; + +/** + * @author Fitz.Lu + **/ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class BindMsgMessage implements BinanceDexTransactionMessage, AminoSerializable { + + @JsonProperty(value = "from") + @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) + private Bech32AddressValue from; + + @JsonProperty(value = "symbol") + private String symbol; + + @JsonProperty(value = "amount") + private long amount; + + @JsonProperty(value = "contract_address") + @JsonSerialize(using = EthAddressValueToStringSerializer.class) + private EthAddressValue contractAddress; + + @JsonProperty(value = "contract_decimals") + private int contractDecimal; + + @JsonProperty(value = "expire_time") + private long expireTime; + + public BindMsgMessage() { + } + + public BindMsgMessage(Bech32AddressValue from, String symbol, long amount, EthAddressValue contractAddress, int contractDecimal, long expireTime) { + this.from = from; + this.symbol = symbol; + this.amount = amount; + this.contractAddress = contractAddress; + this.contractDecimal = contractDecimal; + this.expireTime = expireTime; + } + + public Bech32AddressValue getFrom() { + return from; + } + + public void setFrom(Bech32AddressValue from) { + this.from = from; + } + + public String getSymbol() { + return symbol; + } + + public void setSymbol(String symbol) { + this.symbol = symbol; + } + + public long getAmount() { + return amount; + } + + public void setAmount(long amount) { + this.amount = amount; + } + + public EthAddressValue getContractAddress() { + return contractAddress; + } + + public void setContractAddress(EthAddressValue contractAddress) { + this.contractAddress = contractAddress; + } + + public int getContractDecimal() { + return contractDecimal; + } + + public void setContractDecimal(int contractDecimal) { + this.contractDecimal = contractDecimal; + } + + public long getExpireTime() { + return expireTime; + } + + public void setExpireTime(long expireTime) { + this.expireTime = expireTime; + } + + @Override + public void validateBasic() { + if (StringUtils.isEmpty(symbol)){ + throw new IllegalArgumentException("symbol should not be empty"); + } + if (amount <= 0){ + throw new IllegalArgumentException("amount should be larger than 0"); + } + if (contractAddress == null || contractAddress.isDefaultOrEmpty()){ + throw new IllegalArgumentException("contract address should not be empty"); + } + if (contractDecimal < 0){ + throw new IllegalArgumentException("decimal should be no less than 0"); + } + if (expireTime <= 0){ + throw new IllegalArgumentException("expire time should be larger than 0"); + } + } + + @Override + public AminoSerializable newAminoMessage() { + return new BindMsgMessage(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(Bech32AddressValue.class, from, from == null || from.isDefaultOrEmpty()) + .addField(String.class, symbol, StringUtils.isEmpty(symbol)) + .addField(Long.class, amount, amount == 0) + .addField(EthAddressValue.class, contractAddress, contractAddress == null || contractAddress.isDefaultOrEmpty()) + .addField(Integer.class, contractDecimal, contractDecimal == 0) + .addField(Long.class, expireTime, expireTime == 0) + .build(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + from = ((Bech32AddressValue) value); + break; + case 2: + symbol = ((String) value); + break; + case 3: + amount = ((long) value); + break; + case 4: + contractAddress = ((EthAddressValue) value); + break; + case 5: + contractDecimal = ((int) value); + break; + case 6: + expireTime = ((long) value); + break; + } + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/BindStatus.java b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/BindStatus.java new file mode 100644 index 0000000..e1caf54 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/BindStatus.java @@ -0,0 +1,13 @@ +package com.binance.dex.api.client.encoding.message.bridge; + +/** + * @author Fitz.Lu + **/ +public class BindStatus { + + public static final int bindStatusSuccess = 0; + public static final int bindStatusRejected = 1; + public static final int bindStatusTimeout = 2; + public static final int bindStatusInvalidParameter = 3; + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/ClaimMsgMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/ClaimMsgMessage.java new file mode 100644 index 0000000..28d3b5a --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/ClaimMsgMessage.java @@ -0,0 +1,125 @@ +package com.binance.dex.api.client.encoding.message.bridge; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.encoding.serializer.Bech32AddressValueToStringSerializer; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import org.apache.commons.lang3.StringUtils; + +import java.util.ArrayList; + +/** + * @author Fitz.Lu + **/ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class ClaimMsgMessage implements BinanceDexTransactionMessage, AminoSerializable { + + @JsonProperty(value = "claim_type") + private int claimType; + + @JsonProperty(value = "sequence") + private long sequence; + + @JsonProperty(value = "claim") + private String claim; + + @JsonProperty(value = "validator_address") + @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) + private Bech32AddressValue validatorAddress; + + public ClaimMsgMessage() { + } + + public ClaimMsgMessage(int claimType, long sequence, String claim, Bech32AddressValue validatorAddress) { + this.claimType = claimType; + this.sequence = sequence; + this.claim = claim; + this.validatorAddress = validatorAddress; + } + + public int getClaimType() { + return claimType; + } + + public void setClaimType(int claimType) { + this.claimType = claimType; + } + + public long getSequence() { + return sequence; + } + + public void setSequence(long sequence) { + this.sequence = sequence; + } + + public String getClaim() { + return claim; + } + + public void setClaim(String claim) { + this.claim = claim; + } + + public Bech32AddressValue getValidatorAddress() { + return validatorAddress; + } + + public void setValidatorAddress(Bech32AddressValue validatorAddress) { + this.validatorAddress = validatorAddress; + } + + @Override + public void validateBasic() { + if (!ClaimTypes.IsValidClaimType(claimType)){ + throw new IllegalArgumentException(String.format("claim type %s does not exist, see class ClaimTypes", claimType)); + } + if (sequence < 0){ + throw new IllegalArgumentException("sequence should not be less than 0"); + } + if (StringUtils.isEmpty(claim)){ + throw new IllegalArgumentException("claim should not be empty"); + } + } + + @Override + public AminoSerializable newAminoMessage() { + return new ClaimMsgMessage(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(Integer.class, claimType, false) + .addField(Long.class, sequence, false) + .addField(String.class, claim, StringUtils.isEmpty(claim)) + .addField(Bech32AddressValue.class, validatorAddress, validatorAddress == null ||validatorAddress.isDefaultOrEmpty()) + .build(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + claimType = ((int) value); + break; + case 2: + sequence = ((long) value); + break; + case 3: + claim = ((String) value); + break; + case 4: + validatorAddress = (Bech32AddressValue) value; + break; + default: + break; + } + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/ClaimType.java b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/ClaimType.java new file mode 100644 index 0000000..ed9ec21 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/ClaimType.java @@ -0,0 +1,14 @@ +package com.binance.dex.api.client.encoding.message.bridge; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * @author Fitz.Lu + **/ +@Target(ElementType.FIELD) +@Retention(RetentionPolicy.SOURCE) +public @interface ClaimType { +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/ClaimTypes.java b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/ClaimTypes.java new file mode 100644 index 0000000..60a423d --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/ClaimTypes.java @@ -0,0 +1,41 @@ +package com.binance.dex.api.client.encoding.message.bridge; + +import java.util.HashMap; + +/** + * @author Fitz.Lu + **/ +public class ClaimTypes { + + public static final int ClaimTypeSkipSequence = 0x1; + public static final int ClaimTypeUpdateBind = 0x2; + public static final int ClaimTypeUpdateTransferOut = 0x3; + public static final int ClaimTypeTransferIn = 0x4; + + private static final String ClaimTypeSkipSequenceName = "SkipSequence"; + private static final String ClaimTypeUpdateBindName = "UpdateBind"; + private static final String ClaimTypeUpdateTransferOutName = "UpdateTransferOut"; + private static final String ClaimTypeTransferInName = "TransferIn"; + + private static final HashMap claimTypeToName; + private static final HashMap claimNameToType; + + static { + claimTypeToName = new HashMap<>(); + claimTypeToName.put(ClaimTypeSkipSequence, ClaimTypeSkipSequenceName); + claimTypeToName.put(ClaimTypeUpdateBind, ClaimTypeUpdateBindName); + claimTypeToName.put(ClaimTypeUpdateTransferOut, ClaimTypeUpdateTransferOutName); + claimTypeToName.put(ClaimTypeTransferIn, ClaimTypeTransferInName); + + claimNameToType = new HashMap<>(); + claimNameToType.put(ClaimTypeSkipSequenceName, ClaimTypeSkipSequence); + claimNameToType.put(ClaimTypeUpdateBindName, ClaimTypeUpdateBind); + claimNameToType.put(ClaimTypeUpdateTransferOutName, ClaimTypeUpdateTransferOut); + claimNameToType.put(ClaimTypeTransferInName, ClaimTypeTransferIn); + } + + public static boolean IsValidClaimType(int type){ + return claimTypeToName.containsKey(type); + } + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/DBProphecy.java b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/DBProphecy.java new file mode 100644 index 0000000..f4919eb --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/DBProphecy.java @@ -0,0 +1,84 @@ +package com.binance.dex.api.client.encoding.message.bridge; + +import com.binance.dex.api.client.encoding.ByteUtil; +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import org.apache.commons.lang3.StringUtils; + +import java.util.ArrayList; + +/** + * @author Fitz.Lu + **/ +public class DBProphecy implements AminoSerializable { + + private String id; + + private StatusValue status; + + private byte[] validatorClaims; + + public DBProphecy() { + } + + public DBProphecy(String id, StatusValue status, byte[] validatorClaims) { + this.id = id; + this.status = status; + this.validatorClaims = validatorClaims; + } + + public String getId() { + return id; + } + + public void setId(String id) { + this.id = id; + } + + public StatusValue getStatus() { + return status; + } + + public void setStatus(StatusValue status) { + this.status = status; + } + + public byte[] getValidatorClaims() { + return validatorClaims; + } + + public void setValidatorClaims(byte[] validatorClaims) { + this.validatorClaims = validatorClaims; + } + + @Override + public AminoSerializable newAminoMessage() { + return new DBProphecy(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(String.class, id, StringUtils.isEmpty(id)) + .addField(StatusValue.class, status, status == null) + .addField(byte[].class, validatorClaims, ByteUtil.isEmpty(validatorClaims)) + .build(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + id = ((String) value); + break; + case 2: + status = ((StatusValue) value); + break; + case 3: + validatorClaims = ((byte[]) value); + break; + default: + break; + } + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/RefundReason.java b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/RefundReason.java new file mode 100644 index 0000000..09f41f7 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/RefundReason.java @@ -0,0 +1,13 @@ +package com.binance.dex.api.client.encoding.message.bridge; + +/** + * @author Fitz.Lu + **/ +public class RefundReason { + + public static final int unboundToken = 1; + public static final int timeout = 2; + public static final int insufficientBalance = 3; + public static final int unknown = 4; + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/StatusValue.java b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/StatusValue.java new file mode 100644 index 0000000..2cd8ef9 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/StatusValue.java @@ -0,0 +1,58 @@ +package com.binance.dex.api.client.encoding.message.bridge; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import org.apache.commons.lang3.StringUtils; + +import java.util.ArrayList; + +/** + * @author Fitz.Lu + **/ +public class StatusValue implements AminoSerializable { + + private int text; + + private String finalClaim; + + public int getText() { + return text; + } + + public void setText(int text) { + this.text = text; + } + + public String getFinalClaim() { + return finalClaim; + } + + public void setFinalClaim(String finalClaim) { + this.finalClaim = finalClaim; + } + + @Override + public AminoSerializable newAminoMessage() { + return new StatusValue(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(Integer.class, text, false) + .addField(String.class, finalClaim, StringUtils.isEmpty(finalClaim)) + .build(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + text = ((Integer) value); + break; + case 2: + finalClaim = ((String) value); + break; + } + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/TransferInClaimMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/TransferInClaimMessage.java new file mode 100644 index 0000000..c693249 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/TransferInClaimMessage.java @@ -0,0 +1,93 @@ +package com.binance.dex.api.client.encoding.message.bridge; + +import com.binance.dex.api.client.encoding.message.common.CoinValue; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; + +import java.util.List; + +/** + * @author Fitz.Lu + **/ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class TransferInClaimMessage { + + @JsonProperty(value = "contract_address") + private String contractAddress; + + @JsonProperty(value = "refund_addresses") + private List refundAddresses; + + @JsonProperty(value = "receiver_addresses") + private List receiverAddresses; + + @JsonProperty(value = "amounts") + private List amounts; + + @JsonProperty(value = "symbol") + private String symbol; + + @JsonProperty(value = "relay_fee") + private CoinValue relayFee; + + @JsonProperty(value = "expire_time") + private long expireTime; + + public String getContractAddress() { + return contractAddress; + } + + public void setContractAddress(String contractAddress) { + this.contractAddress = contractAddress; + } + + public List getRefundAddresses() { + return refundAddresses; + } + + public void setRefundAddresses(List refundAddresses) { + this.refundAddresses = refundAddresses; + } + + public List getReceiverAddresses() { + return receiverAddresses; + } + + public void setReceiverAddresses(List receiverAddresses) { + this.receiverAddresses = receiverAddresses; + } + + public List getAmounts() { + return amounts; + } + + public void setAmounts(List amounts) { + this.amounts = amounts; + } + + public String getSymbol() { + return symbol; + } + + public void setSymbol(String symbol) { + this.symbol = symbol; + } + + public CoinValue getRelayFee() { + return relayFee; + } + + public void setRelayFee(CoinValue relayFee) { + this.relayFee = relayFee; + } + + public long getExpireTime() { + return expireTime; + } + + public void setExpireTime(long expireTime) { + this.expireTime = expireTime; + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/TransferOutMsgMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/TransferOutMsgMessage.java new file mode 100644 index 0000000..cf3cd84 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/TransferOutMsgMessage.java @@ -0,0 +1,117 @@ +package com.binance.dex.api.client.encoding.message.bridge; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.encoding.message.common.CoinValue; +import com.binance.dex.api.client.encoding.message.common.EthAddressValue; +import com.binance.dex.api.client.encoding.serializer.Bech32AddressValueToStringSerializer; +import com.binance.dex.api.client.encoding.serializer.EthAddressValueToStringSerializer; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; + +import java.util.ArrayList; + +/** + * @author Fitz.Lu + **/ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class TransferOutMsgMessage implements BinanceDexTransactionMessage, AminoSerializable { + + @JsonProperty(value = "from") + @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) + private Bech32AddressValue from; + + @JsonProperty(value = "to") + @JsonSerialize(using = EthAddressValueToStringSerializer.class) + private EthAddressValue toAddress; + + @JsonProperty(value = "amount") + private CoinValue amount; + + @JsonProperty(value = "expire_time") + private long expireTime; + + public Bech32AddressValue getFrom() { + return from; + } + + public void setFrom(Bech32AddressValue from) { + this.from = from; + } + + public EthAddressValue getToAddress() { + return toAddress; + } + + public void setToAddress(EthAddressValue toAddress) { + this.toAddress = toAddress; + } + + public CoinValue getAmount() { + return amount; + } + + public void setAmount(CoinValue amount) { + this.amount = amount; + } + + public long getExpireTime() { + return expireTime; + } + + public void setExpireTime(long expireTime) { + this.expireTime = expireTime; + } + + @Override + public void validateBasic() { + if (toAddress == null || toAddress.isDefaultOrEmpty()){ + throw new IllegalArgumentException("to address should not be empty"); + } + if (amount == null || amount.getAmount() <= 0){ + throw new IllegalArgumentException("amount should be positive"); + } + if (expireTime <= 0){ + throw new IllegalArgumentException("expire time should be larger than 0"); + } + } + + @Override + public AminoSerializable newAminoMessage() { + return new TransferOutMsgMessage(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(Bech32AddressValue.class, from, from == null) + .addField(EthAddressValue.class, toAddress, toAddress == null) + .addField(CoinValue.class, amount, amount == null) + .addField(Long.class, expireTime, expireTime == 0) + .build(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + from = ((Bech32AddressValue) value); + break; + case 2: + toAddress = ((EthAddressValue) value); + break; + case 3: + amount = ((CoinValue) value); + break; + case 4: + expireTime = ((long) value); + break; + } + } + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/UpdateBindClaimMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/UpdateBindClaimMessage.java new file mode 100644 index 0000000..95e4dbb --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/UpdateBindClaimMessage.java @@ -0,0 +1,87 @@ +package com.binance.dex.api.client.encoding.message.bridge; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; +import com.binance.dex.api.client.encoding.message.common.EthAddressValue; +import com.binance.dex.api.client.encoding.serializer.EthAddressValueToStringSerializer; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import org.apache.commons.lang3.StringUtils; + +import java.util.ArrayList; + +/** + * @author Fitz.Lu + **/ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class UpdateBindClaimMessage implements BinanceDexTransactionMessage, AminoSerializable { + + @JsonProperty(value = "status") + private int status; + + @JsonProperty(value = "symbol") + private String symbol; + + @JsonProperty(value = "contract_address") + @JsonSerialize(using = EthAddressValueToStringSerializer.class) + private EthAddressValue contractAddress; + + public int getStatus() { + return status; + } + + public void setStatus(int status) { + this.status = status; + } + + public String getSymbol() { + return symbol; + } + + public void setSymbol(String symbol) { + this.symbol = symbol; + } + + public EthAddressValue getContractAddress() { + return contractAddress; + } + + public void setContractAddress(EthAddressValue contractAddress) { + this.contractAddress = contractAddress; + } + + @Override + public AminoSerializable newAminoMessage() { + return new UpdateBindClaimMessage(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(Integer.class, status, false) + .addField(String.class, symbol, StringUtils.isEmpty(symbol)) + .addField(EthAddressValue.class, contractAddress, contractAddress == null || contractAddress.isDefaultOrEmpty()) + .build(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + status = ((int) value); + break; + case 2: + symbol = ((String) value); + break; + case 3: + contractAddress = ((EthAddressValue) value); + break; + default: + break; + } + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/UpdateTransferOutClaimMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/UpdateTransferOutClaimMessage.java new file mode 100644 index 0000000..3b7734b --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/UpdateTransferOutClaimMessage.java @@ -0,0 +1,87 @@ +package com.binance.dex.api.client.encoding.message.bridge; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.encoding.message.common.CoinValue; +import com.binance.dex.api.client.encoding.serializer.Bech32AddressValueToStringSerializer; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; + +import java.util.ArrayList; + +/** + * @author Fitz.Lu + **/ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class UpdateTransferOutClaimMessage implements BinanceDexTransactionMessage, AminoSerializable { + + @JsonProperty(value = "refund_address") + @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) + private Bech32AddressValue refundAddress; + + @JsonProperty(value = "amount") + private CoinValue amount; + + @JsonProperty(value = "refund_reason") + private int refundReason; + + public Bech32AddressValue getRefundAddress() { + return refundAddress; + } + + public void setRefundAddress(Bech32AddressValue refundAddress) { + this.refundAddress = refundAddress; + } + + public CoinValue getAmount() { + return amount; + } + + public void setAmount(CoinValue amount) { + this.amount = amount; + } + + public int getRefundReason() { + return refundReason; + } + + public void setRefundReason(int refundReason) { + this.refundReason = refundReason; + } + + @Override + public AminoSerializable newAminoMessage() { + return new UpdateTransferOutClaimMessage(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(Bech32AddressValue.class, refundAddress, refundAddress == null || refundAddress.isDefaultOrEmpty()) + .addField(CoinValue.class, amount, amount == null) + .addField(Integer.class, refundReason, false) + .build(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + refundAddress = ((Bech32AddressValue) value); + break; + case 2: + amount = ((CoinValue) value); + break; + case 3: + refundReason = ((int) value); + break; + default: + break; + } + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/common/Bech32AddressValue.java b/src/main/java/com/binance/dex/api/client/encoding/message/common/Bech32AddressValue.java new file mode 100644 index 0000000..fb1e5c5 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/common/Bech32AddressValue.java @@ -0,0 +1,94 @@ +package com.binance.dex.api.client.encoding.message.common; + +import com.binance.dex.api.client.encoding.Bech32; +import com.binance.dex.api.client.encoding.ByteUtil; +import com.binance.dex.api.client.encoding.Crypto; +import com.binance.dex.api.client.encoding.amino.AminoCustomSerialized; +import com.binance.dex.api.client.encoding.amino.WireType; +import com.google.protobuf.CodedInputStream; +import com.google.protobuf.CodedOutputStream; + +import java.io.IOException; + +/** + * @author Fitz.Lu + **/ +public class Bech32AddressValue implements AminoCustomSerialized { + + private String hrp; + + private byte[] raw; + + public static Bech32AddressValue fromBech32String(String address){ + return new Bech32AddressValue(address); + } + + public static Bech32AddressValue fromBech32StringWithNewHrp(String originalAddress, String hrp){ + return new Bech32AddressValue(originalAddress, hrp); + } + + public Bech32AddressValue() { } + + public Bech32AddressValue(String address) { + this.hrp = Bech32.decode(address).getHrp(); + this.raw = Crypto.decodeAddress(address); + } + + public Bech32AddressValue(String originalAddress, String hrp){ + this.hrp = hrp; + this.raw = Crypto.decodeAddress(originalAddress); + } + + public String getHrp() { + return hrp; + } + + public void setHrp(String hrp) { + this.hrp = hrp; + } + + public void setRaw(byte[] raw) { + this.raw = raw; + } + + public byte[] getRaw(){ + return raw; + } + + @Override + public AminoCustomSerialized newAminoSerInstance() { + return new Bech32AddressValue(); + } + + @Override + public boolean isDefaultOrEmpty() { + return ByteUtil.isEmpty(raw); + } + + @Override + public int getWireType() { + return WireType.LENGTH_DELIMITED; + } + + @Override + public void encode(CodedOutputStream outputStream) throws IOException { + if (raw != null) { + outputStream.writeByteArrayNoTag(raw); + } + } + + @Override + public void decode(CodedInputStream inputStream) throws IOException { + raw = inputStream.readByteArray(); + } + + @Override + public int getSerializedSize() { + if (ByteUtil.isEmpty(raw)) { + return 0; + }else{ + return CodedOutputStream.computeByteArraySizeNoTag(raw); + } + } + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/CoinValue.java b/src/main/java/com/binance/dex/api/client/encoding/message/common/CoinValue.java similarity index 86% rename from src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/CoinValue.java rename to src/main/java/com/binance/dex/api/client/encoding/message/common/CoinValue.java index feb4174..9002d64 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/CoinValue.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/common/CoinValue.java @@ -1,13 +1,11 @@ -package com.binance.dex.api.client.encoding.message.sidechain.value; +package com.binance.dex.api.client.encoding.message.common; import com.binance.dex.api.client.encoding.amino.AminoField; import com.binance.dex.api.client.encoding.amino.AminoSerializable; import com.binance.dex.api.client.encoding.message.Token; -import com.binance.dex.api.client.encoding.serializer.LongToStringSerializer; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.annotation.JsonPropertyOrder; -import com.fasterxml.jackson.databind.annotation.JsonSerialize; import org.apache.commons.lang3.StringUtils; import java.util.ArrayList; @@ -23,7 +21,6 @@ public class CoinValue implements AminoSerializable { private String denom; @JsonProperty(value = "amount") - @JsonSerialize(using = LongToStringSerializer.class) private long amount; public CoinValue() { @@ -59,7 +56,7 @@ public void setAmount(long amount) { @Override public AminoSerializable newAminoMessage() { - return new CoinValue(); + return new CoinValueStr(); } @Override @@ -83,4 +80,5 @@ public void setValueByFieldIndex(int fieldIndex, Object value) { break; } } + } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/TokenMessageValue.java b/src/main/java/com/binance/dex/api/client/encoding/message/common/CoinValueStr.java similarity index 68% rename from src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/TokenMessageValue.java rename to src/main/java/com/binance/dex/api/client/encoding/message/common/CoinValueStr.java index 78a26d6..84613ec 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/TokenMessageValue.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/common/CoinValueStr.java @@ -1,7 +1,8 @@ -package com.binance.dex.api.client.encoding.message.sidechain.value; +package com.binance.dex.api.client.encoding.message.common; import com.binance.dex.api.client.encoding.amino.AminoField; import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.Token; import com.binance.dex.api.client.encoding.serializer.LongToStringSerializer; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; @@ -16,7 +17,7 @@ **/ @JsonIgnoreProperties(ignoreUnknown = true) @JsonPropertyOrder(alphabetic = true) -public class TokenMessageValue implements AminoSerializable { +public class CoinValueStr implements AminoSerializable { @JsonProperty(value = "denom") private String denom; @@ -25,7 +26,20 @@ public class TokenMessageValue implements AminoSerializable { @JsonSerialize(using = LongToStringSerializer.class) private long amount; - public TokenMessageValue() { } + public CoinValueStr() { + } + + public CoinValueStr(String denom, Long amount) { + this.denom = denom; + this.amount = amount; + } + + public Token toToken(){ + Token token = new Token(); + token.setDenom(denom); + token.setAmount(amount); + return token; + } public String getDenom() { return denom; @@ -45,7 +59,15 @@ public void setAmount(long amount) { @Override public AminoSerializable newAminoMessage() { - return new TokenMessageValue(); + return new CoinValueStr(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(String.class, denom, StringUtils.isEmpty(denom)) + .addField(Long.class, amount, amount == 0) + .build(); } @Override @@ -61,13 +83,4 @@ public void setValueByFieldIndex(int fieldIndex, Object value) { break; } } - - @Override - public ArrayList> IterateFields() { - ArrayList> fields = new ArrayList<>(); - fields.add(new AminoField<>(String.class, denom, StringUtils.isEmpty(denom))); - fields.add(new AminoField<>(Long.class, amount, amount == 0)); - return fields; - } - } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/Dec.java b/src/main/java/com/binance/dex/api/client/encoding/message/common/Dec.java similarity index 94% rename from src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/Dec.java rename to src/main/java/com/binance/dex/api/client/encoding/message/common/Dec.java index 200c8f3..32e9f50 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/Dec.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/common/Dec.java @@ -1,4 +1,4 @@ -package com.binance.dex.api.client.encoding.message.sidechain.value; +package com.binance.dex.api.client.encoding.message.common; import com.binance.dex.api.client.encoding.amino.AminoCustomSerialized; import com.binance.dex.api.client.encoding.amino.WireType; @@ -10,6 +10,7 @@ /** * @author Fitz.Lu **/ +@Deprecated public class Dec implements AminoCustomSerialized { private long value; diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/AddressValue.java b/src/main/java/com/binance/dex/api/client/encoding/message/common/EthAddressValue.java similarity index 67% rename from src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/AddressValue.java rename to src/main/java/com/binance/dex/api/client/encoding/message/common/EthAddressValue.java index 79999c3..071f2be 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/AddressValue.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/common/EthAddressValue.java @@ -1,29 +1,29 @@ -package com.binance.dex.api.client.encoding.message.sidechain.value; +package com.binance.dex.api.client.encoding.message.common; -import com.binance.dex.api.client.encoding.Crypto; import com.binance.dex.api.client.encoding.amino.AminoCustomSerialized; import com.binance.dex.api.client.encoding.amino.WireType; import com.google.protobuf.CodedInputStream; import com.google.protobuf.CodedOutputStream; import org.apache.commons.lang3.StringUtils; +import org.bouncycastle.util.encoders.Hex; import java.io.IOException; /** * @author Fitz.Lu **/ -public class AddressValue implements AminoCustomSerialized { +public class EthAddressValue implements AminoCustomSerialized { private String address; - public static AddressValue from(String value){ - return new AddressValue(value); + public static EthAddressValue from(String addr){ + return new EthAddressValue(addr); } - public AddressValue() { + public EthAddressValue() { } - public AddressValue(String address) { + public EthAddressValue(String address) { this.address = address; } @@ -37,7 +37,7 @@ public void setAddress(String address) { @Override public AminoCustomSerialized newAminoSerInstance() { - return new AddressValue(); + return new EthAddressValue(); } @Override @@ -46,24 +46,25 @@ public boolean isDefaultOrEmpty() { } @Override - public int getWireType() { - return WireType.LENGTH_DELIMITED; + public void encode(CodedOutputStream outputStream) throws IOException { + outputStream.writeByteArrayNoTag(getValueBytes()); } @Override - public void encode(CodedOutputStream outputStream) throws IOException { - outputStream.writeByteArrayNoTag(getValueBytes()); + public int getWireType() { + return WireType.LENGTH_DELIMITED; } @Override public void decode(CodedInputStream inputStream) throws IOException { byte[] bytes = inputStream.readByteArray(); -// address = Bech32.encode("bnb", bytes); + address = Hex.toHexString(bytes); + address = "0x" + address; } @Override public int getSerializedSize() { - if (StringUtils.isEmpty(address)) { + if (StringUtils.isEmpty(address)){ return 0; }else{ return CodedOutputStream.computeByteArraySizeNoTag(getValueBytes()); @@ -71,7 +72,10 @@ public int getSerializedSize() { } private byte[] getValueBytes(){ - return Crypto.decodeAddress(address); + String addr = address; + if (addr.startsWith("0x")){ + addr = address.substring(2); + } + return Hex.decode(addr); } - } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/SideChainClassConverter.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/SideChainClassConverter.java deleted file mode 100644 index f8cac48..0000000 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/SideChainClassConverter.java +++ /dev/null @@ -1,75 +0,0 @@ -package com.binance.dex.api.client.encoding.message.sidechain; - -import com.binance.dex.api.client.domain.sidechain.*; -import com.binance.dex.api.client.encoding.message.Token; -import com.binance.dex.api.client.encoding.message.sidechain.transaction.SideChainDelegateMessage; -import com.binance.dex.api.client.encoding.message.sidechain.transaction.SideChainRedelegateMessage; -import com.binance.dex.api.client.encoding.message.sidechain.transaction.SideChainUndelegateMessage; -import com.binance.dex.api.client.encoding.message.sidechain.value.*; - -/** - * @author Fitz.Lu - **/ -public class SideChainClassConverter { - - public static DescriptionValue convert(Description description){ - DescriptionValue value = new DescriptionValue(); - value.setMoniker(description.getMoniker()); - value.setDetails(description.getDetails()); - value.setIdentity(description.getIdentity()); - value.setWebsite(description.getWebsite()); - return value; - } - - public static CommissionMsgValue convert(Commission commission){ - CommissionMsgValue value = new CommissionMsgValue(); - value.setRate(Dec.newInstance(commission.getRate())); - value.setMaxRate(Dec.newInstance(commission.getMaxRate())); - value.setMaxChangeRate(Dec.newInstance(commission.getMaxChangeRate())); - return value; - } - - public static CoinValue convert(Token token){ - CoinValue value = new CoinValue(); - value.setDenom(token.getDenom()); - value.setAmount(token.getAmount()); - return value; - } - - public static SideChainDelegateMessage convert(SideChainDelegate sideChainDelegate){ - SideChainDelegateMessage message = new SideChainDelegateMessage(); - message.setDelegatorAddress(AddressValue.from(sideChainDelegate.getDelegatorAddress())); - message.setValidatorAddress(AddressValue.from(sideChainDelegate.getValidatorAddress())); - - if (sideChainDelegate.getDelegation() != null) { - message.setDelegation(convert(sideChainDelegate.getDelegation())); - } - - message.setSideChainId(sideChainDelegate.getSideChainId()); - return message; - } - - public static SideChainRedelegateMessage convert(SideChainRedelegate redelegate){ - SideChainRedelegateMessage message = new SideChainRedelegateMessage(); - message.setDelegatorAddress(AddressValue.from(redelegate.getDelegatorAddress())); - message.setSrcValidatorAddress(AddressValue.from(redelegate.getSrcValidatorAddress())); - message.setDstValidatorAddress(AddressValue.from(redelegate.getDstValidatorAddress())); - if (redelegate.getAmount() != null) { - message.setAmount(convert(redelegate.getAmount())); - } - message.setSideChainId(redelegate.getSideChainId()); - return message; - } - - public static SideChainUndelegateMessage convert(SideChainUnBond unBond){ - SideChainUndelegateMessage message = new SideChainUndelegateMessage(); - message.setDelegatorAddress(AddressValue.from(unBond.getDelegatorAddress())); - message.setValidatorAddress(AddressValue.from(unBond.getValidatorAddress())); - if (unBond.getAmount() != null) { - message.setAmount(convert(unBond.getAmount())); - } - message.setSideChainId(unBond.getSideChainId()); - return message; - } - -} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/BaseQueryParams.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/BaseQueryParams.java new file mode 100644 index 0000000..f1a24b0 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/BaseQueryParams.java @@ -0,0 +1,27 @@ +package com.binance.dex.api.client.encoding.message.sidechain.query; + +import com.fasterxml.jackson.annotation.JsonProperty; + +/** + * @author Fitz.Lu + **/ +public class BaseQueryParams { + + @JsonProperty(value = "SideChainId") + private String sideChainId; + + public BaseQueryParams() { + } + + public BaseQueryParams(String sideChainId) { + this.sideChainId = sideChainId; + } + + public String getSideChainId() { + return sideChainId; + } + + public void setSideChainId(String sideChainId) { + this.sideChainId = sideChainId; + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/BechValidator.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/BechValidator.java index 41cc16f..9244f23 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/BechValidator.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/BechValidator.java @@ -1,8 +1,8 @@ package com.binance.dex.api.client.encoding.message.sidechain.query; -import com.binance.dex.api.client.domain.sidechain.Commission; -import com.binance.dex.api.client.domain.sidechain.Description; -import com.binance.dex.api.client.domain.sidechain.SideChainValidator; +import com.binance.dex.api.client.domain.stake.Commission; +import com.binance.dex.api.client.domain.stake.Description; +import com.binance.dex.api.client.domain.stake.sidechain.SideChainValidator; import com.binance.dex.api.client.encoding.Crypto; import com.binance.dex.api.client.encoding.amino.Amino; import com.binance.dex.api.client.encoding.message.sidechain.value.DescriptionValue; @@ -122,10 +122,10 @@ public BechValidator() { public SideChainValidator toSideChainValidator() { SideChainValidator validator = new SideChainValidator(); if (feeAddr != null) { - validator.setFeeAddr(Crypto.decodeAddress(feeAddr)); + validator.setFeeAddr(feeAddr); } if (operatorAddr != null) { - validator.setOperatorAddr(Crypto.decodeAddress(operatorAddr)); + validator.setOperatorAddr(operatorAddr); } if (consPubKey != null) { try { @@ -164,14 +164,14 @@ public SideChainValidator toSideChainValidator() { if (!StringUtils.isEmpty(sideChainId)) { if (distributionAddr != null) { - validator.setDistributionAddr(distributionAddr.getBytes()); + validator.setDistributionAddr(distributionAddr); } validator.setSideChainId(sideChainId); if (sideConsAddr != null) { - validator.setSideConsAddr(sideConsAddr.getBytes()); + validator.setSideConsAddr(sideConsAddr); } if (sideFeeAddr != null) { - validator.setSideFeeAddr(sideFeeAddr.getBytes()); + validator.setSideFeeAddr(sideFeeAddr); } } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/PoolMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/PoolMessage.java new file mode 100644 index 0000000..254f36b --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/PoolMessage.java @@ -0,0 +1,60 @@ +package com.binance.dex.api.client.encoding.message.sidechain.query; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.common.Dec; + +import java.util.ArrayList; + +/** + * @author Fitz.Lu + **/ +public class PoolMessage implements AminoSerializable { + + private Dec looseTokens; + + private Dec bondedTokens; + + public Dec getLooseTokens() { + return looseTokens; + } + + public void setLooseTokens(Dec looseTokens) { + this.looseTokens = looseTokens; + } + + public Dec getBondedTokens() { + return bondedTokens; + } + + public void setBondedTokens(Dec bondedTokens) { + this.bondedTokens = bondedTokens; + } + + @Override + public AminoSerializable newAminoMessage() { + return new PoolMessage(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(Dec.class, looseTokens, looseTokens == null) + .addField(Dec.class, bondedTokens, bondedTokens == null) + .build(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + looseTokens = ((Dec) value); + break; + case 2: + bondedTokens = ((Dec) value); + break; + default: + break; + } + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryValidatorParams.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryValidatorParams.java new file mode 100644 index 0000000..9e75cc1 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryValidatorParams.java @@ -0,0 +1,43 @@ +package com.binance.dex.api.client.encoding.message.sidechain.query; + +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.encoding.serializer.Bech32AddressValueToStringSerializer; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; + +/** + * @author Fitz.Lu + **/ +public class QueryValidatorParams { + + @JsonProperty(value = "SideChainId") + private String sideChainId; + + @JsonProperty(value = "ValidatorAddr") + @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) + private Bech32AddressValue ValidatorAddress; + + public QueryValidatorParams() { + } + + public QueryValidatorParams(String sideChainId, Bech32AddressValue validatorAddress) { + this.sideChainId = sideChainId; + ValidatorAddress = validatorAddress; + } + + public String getSideChainId() { + return sideChainId; + } + + public void setSideChainId(String sideChainId) { + this.sideChainId = sideChainId; + } + + public Bech32AddressValue getValidatorAddress() { + return ValidatorAddress; + } + + public void setValidatorAddress(Bech32AddressValue validatorAddress) { + ValidatorAddress = validatorAddress; + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/SideChainRedelegationMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/SideChainRedelegationMessage.java index cf307b8..1ac0559 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/SideChainRedelegationMessage.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/SideChainRedelegationMessage.java @@ -1,60 +1,68 @@ package com.binance.dex.api.client.encoding.message.sidechain.query; -import com.binance.dex.api.client.encoding.amino.AminoField; -import com.binance.dex.api.client.encoding.amino.AminoSerializable; -import com.binance.dex.api.client.encoding.message.sidechain.value.CoinValue; -import com.binance.dex.api.client.encoding.message.sidechain.value.Dec; -import com.binance.dex.api.client.encoding.message.sidechain.value.TimestampValue; - -import java.util.ArrayList; +import com.binance.dex.api.client.encoding.message.common.CoinValue; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; /** * @author Fitz.Lu **/ -public class SideChainRedelegationMessage implements AminoSerializable { +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class SideChainRedelegationMessage { - private byte[] delegatorAddress; + @JsonProperty(value = "delegator_addr") + private String delegatorAddress; - private byte[] srcValidatorAddress; + @JsonProperty(value = "validator_src_addr") + private String srcValidatorAddress; - private byte[] dstValidatorAddress; + @JsonProperty(value = "validator_dst_addr") + private String dstValidatorAddress; + @JsonProperty(value = "creation_height") private long createHeight; - private TimestampValue minTime = new TimestampValue(); + @JsonProperty(value = "min_time") + private String minTime; - private CoinValue initialBalance = new CoinValue(); + @JsonProperty(value = "initial_balance") + private CoinValue initialBalance; - private CoinValue balance = new CoinValue(); + @JsonProperty(value = "balance") + private CoinValue balance; - private Dec srcShares = new Dec(); + @JsonProperty(value = "shares_src") + private long srcShares; - private Dec dstShare = new Dec(); + @JsonProperty(value = "shares_dst") + private long dstShare; public SideChainRedelegationMessage() { } - public byte[] getDelegatorAddress() { + public String getDelegatorAddress() { return delegatorAddress; } - public void setDelegatorAddress(byte[] delegatorAddress) { + public void setDelegatorAddress(String delegatorAddress) { this.delegatorAddress = delegatorAddress; } - public byte[] getSrcValidatorAddress() { + public String getSrcValidatorAddress() { return srcValidatorAddress; } - public void setSrcValidatorAddress(byte[] srcValidatorAddress) { + public void setSrcValidatorAddress(String srcValidatorAddress) { this.srcValidatorAddress = srcValidatorAddress; } - public byte[] getDstValidatorAddress() { + public String getDstValidatorAddress() { return dstValidatorAddress; } - public void setDstValidatorAddress(byte[] dstValidatorAddress) { + public void setDstValidatorAddress(String dstValidatorAddress) { this.dstValidatorAddress = dstValidatorAddress; } @@ -66,11 +74,11 @@ public void setCreateHeight(long createHeight) { this.createHeight = createHeight; } - public TimestampValue getMinTime() { + public String getMinTime() { return minTime; } - public void setMinTime(TimestampValue minTime) { + public void setMinTime(String minTime) { this.minTime = minTime; } @@ -90,74 +98,19 @@ public void setBalance(CoinValue balance) { this.balance = balance; } - public Dec getSrcShares() { + public long getSrcShares() { return srcShares; } - public void setSrcShares(Dec srcShares) { + public void setSrcShares(long srcShares) { this.srcShares = srcShares; } - public Dec getDstShare() { + public long getDstShare() { return dstShare; } - public void setDstShare(Dec dstShare) { + public void setDstShare(long dstShare) { this.dstShare = dstShare; } - - @Override - public AminoSerializable newAminoMessage() { - return new SideChainRedelegationMessage(); - } - - @Override - public ArrayList> IterateFields() { - return AminoField.newFieldsBuilder() - .addField(byte[].class, delegatorAddress, delegatorAddress == null || delegatorAddress.length == 0) - .addField(byte[].class, srcValidatorAddress, srcValidatorAddress == null || srcValidatorAddress.length == 0) - .addField(byte[].class, dstValidatorAddress, dstValidatorAddress == null || dstValidatorAddress.length == 0) - .addField(Long.class, createHeight, createHeight == 0) - .addField(TimestampValue.class, minTime, minTime == null) - .addField(CoinValue.class, initialBalance, initialBalance == null) - .addField(CoinValue.class, balance, balance == null) - .addField(Dec.class, srcShares, srcShares == null || srcShares.isDefaultOrEmpty()) - .addField(Dec.class, dstShare, dstShare == null || dstShare.isDefaultOrEmpty()) - .build(); - } - - @Override - public void setValueByFieldIndex(int fieldIndex, Object value) { - switch (fieldIndex) { - case 1: - delegatorAddress = ((byte[]) value); - break; - case 2: - srcValidatorAddress = ((byte[]) value); - break; - case 3: - dstValidatorAddress = ((byte[]) value); - break; - case 4: - createHeight = ((long) value); - break; - case 5: - minTime = ((TimestampValue) value); - break; - case 6: - initialBalance = ((CoinValue) value); - break; - case 7: - balance = ((CoinValue) value); - break; - case 8: - srcShares = ((Dec) value); - break; - case 9: - dstShare = ((Dec) value); - break; - default: - break; - } - } } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/SideChainUnBondingDelegationMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/SideChainUnBondingDelegationMessage.java deleted file mode 100644 index a512231..0000000 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/SideChainUnBondingDelegationMessage.java +++ /dev/null @@ -1,69 +0,0 @@ -package com.binance.dex.api.client.encoding.message.sidechain.query; - -import com.binance.dex.api.client.encoding.ByteUtil; -import com.binance.dex.api.client.encoding.amino.AminoField; -import com.binance.dex.api.client.encoding.amino.AminoSerializable; -import com.binance.dex.api.client.encoding.message.sidechain.value.CoinValue; - -import java.util.ArrayList; - -/** - * @author Fitz.Lu - **/ -public class SideChainUnBondingDelegationMessage implements AminoSerializable { - - private byte[] delegatorAddress; - - private byte[] validatorAddress; - - private long createHeight; - - private long minTimeInMs; - - private CoinValue initialBalance = new CoinValue(); - - private CoinValue balance = new CoinValue(); - - @Override - public AminoSerializable newAminoMessage() { - return new SideChainUnBondingDelegationMessage(); - } - - @Override - public ArrayList> IterateFields() { - return AminoField.newFieldsBuilder() - .addField(byte[].class, delegatorAddress, ByteUtil.isEmpty(delegatorAddress)) - .addField(byte[].class, validatorAddress, ByteUtil.isEmpty(validatorAddress)) - .addField(Long.class, createHeight, createHeight == 0) - .addField(Long.class, minTimeInMs, minTimeInMs == 0) - .addField(CoinValue.class, initialBalance, initialBalance == null) - .addField(CoinValue.class, balance, balance == null) - .build(); - } - - @Override - public void setValueByFieldIndex(int fieldIndex, Object value) { - switch (fieldIndex) { - case 1: - delegatorAddress = ((byte[]) value); - break; - case 2: - validatorAddress = ((byte[]) value); - break; - case 3: - createHeight = ((Integer) value); - break; - case 4: - minTimeInMs = ((Long) value); - break; - case 5: - initialBalance = ((CoinValue) value); - break; - case 6: - balance = ((CoinValue) value); - break; - default: - break; - } - } -} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/SideChainValidatorMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/SideChainValidatorMessage.java index 0380d7c..decea6a 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/SideChainValidatorMessage.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/SideChainValidatorMessage.java @@ -3,7 +3,7 @@ import com.binance.dex.api.client.encoding.amino.AminoField; import com.binance.dex.api.client.encoding.amino.AminoSerializable; import com.binance.dex.api.client.encoding.message.sidechain.value.CommissionValue; -import com.binance.dex.api.client.encoding.message.sidechain.value.Dec; +import com.binance.dex.api.client.encoding.message.common.Dec; import com.binance.dex.api.client.encoding.message.sidechain.value.DescriptionValue; import org.apache.commons.lang3.StringUtils; import org.bouncycastle.util.encoders.Hex; diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/UnBondingDelegationMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/UnBondingDelegationMessage.java new file mode 100644 index 0000000..f1baa0f --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/UnBondingDelegationMessage.java @@ -0,0 +1,83 @@ +package com.binance.dex.api.client.encoding.message.sidechain.query; + +import com.binance.dex.api.client.encoding.message.Token; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; + +/** + * @author Fitz.Lu + **/ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class UnBondingDelegationMessage { + + @JsonProperty(value = "delegator_addr") + private String delegatorAddress; + + @JsonProperty(value = "validator_addr") + private String validatorAddress; + + @JsonProperty(value = "creation_height") + private long createHeight; + + @JsonProperty(value = "min_time") + private String minTime; + + @JsonProperty(value = "initial_balance") + private Token initialBalance; + + @JsonProperty(value = "balance") + private Token balance; + + public UnBondingDelegationMessage() { + } + + public String getDelegatorAddress() { + return delegatorAddress; + } + + public void setDelegatorAddress(String delegatorAddress) { + this.delegatorAddress = delegatorAddress; + } + + public String getValidatorAddress() { + return validatorAddress; + } + + public void setValidatorAddress(String validatorAddress) { + this.validatorAddress = validatorAddress; + } + + public long getCreateHeight() { + return createHeight; + } + + public void setCreateHeight(long createHeight) { + this.createHeight = createHeight; + } + + public String getMinTime() { + return minTime; + } + + public void setMinTime(String minTime) { + this.minTime = minTime; + } + + public Token getInitialBalance() { + return initialBalance; + } + + public void setInitialBalance(Token initialBalance) { + this.initialBalance = initialBalance; + } + + public Token getBalance() { + return balance; + } + + public void setBalance(Token balance) { + this.balance = balance; + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/CreateSideChainValidatorMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/CreateSideChainValidatorMessage.java index 4ee860d..6fc20cb 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/CreateSideChainValidatorMessage.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/CreateSideChainValidatorMessage.java @@ -3,9 +3,10 @@ import com.binance.dex.api.client.encoding.amino.AminoField; import com.binance.dex.api.client.encoding.amino.AminoSerializable; import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.encoding.message.common.CoinValueStr; import com.binance.dex.api.client.encoding.message.sidechain.value.*; -import com.binance.dex.api.client.encoding.serializer.AccAddressValueToStringSerializer; -import com.binance.dex.api.client.encoding.serializer.ValAddressValueToStringSerializer; +import com.binance.dex.api.client.encoding.serializer.Bech32AddressValueToStringSerializer; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.annotation.JsonPropertyOrder; @@ -25,15 +26,15 @@ public class CreateSideChainValidatorMessage implements BinanceDexTransactionMes private CommissionMsgValue commission = new CommissionMsgValue(); @JsonProperty(value = "delegator_address") - @JsonSerialize(using = AccAddressValueToStringSerializer.class) - private AddressValue delegatorAddr; + @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) + private Bech32AddressValue delegatorAddr; @JsonProperty(value = "validator_address") - @JsonSerialize(using = ValAddressValueToStringSerializer.class) - private AddressValue validatorOperatorAddr; + @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) + private Bech32AddressValue validatorOperatorAddr; @JsonProperty(value = "delegation") - private CoinValue delegation; + private CoinValueStr delegation; @JsonProperty(value = "side_chain_id") private String sideChainId; @@ -44,6 +45,11 @@ public class CreateSideChainValidatorMessage implements BinanceDexTransactionMes @JsonProperty(value = "side_fee_addr") private byte[] sideFeeAddr; + @Override + public boolean useAminoJson() { + return true; + } + @Override public void setValueByFieldIndex(int fieldIndex, Object value) { switch (fieldIndex) { @@ -54,13 +60,13 @@ public void setValueByFieldIndex(int fieldIndex, Object value) { commission = ((CommissionMsgValue) value); break; case 3: - delegatorAddr = ((AddressValue) value); + delegatorAddr = ((Bech32AddressValue) value); break; case 4: - validatorOperatorAddr = ((AddressValue) value); + validatorOperatorAddr = ((Bech32AddressValue) value); break; case 5: - delegation = ((CoinValue) value); + delegation = ((CoinValueStr) value); break; case 6: sideChainId = ((String) value); @@ -86,9 +92,9 @@ public ArrayList> IterateFields() { ArrayList> fields = new ArrayList<>(); fields.add(new AminoField<>(DescriptionValue.class, description, description == null)); fields.add(new AminoField<>(CommissionMsgValue.class, commission, commission == null)); - fields.add(new AminoField<>(AddressValue.class, delegatorAddr, delegatorAddr == null || delegatorAddr.isDefaultOrEmpty())); - fields.add(new AminoField<>(AddressValue.class, validatorOperatorAddr, validatorOperatorAddr == null || validatorOperatorAddr.isDefaultOrEmpty())); - fields.add(new AminoField<>(CoinValue.class, delegation, delegation == null)); + fields.add(new AminoField<>(Bech32AddressValue.class, delegatorAddr, delegatorAddr == null || delegatorAddr.isDefaultOrEmpty())); + fields.add(new AminoField<>(Bech32AddressValue.class, validatorOperatorAddr, validatorOperatorAddr == null || validatorOperatorAddr.isDefaultOrEmpty())); + fields.add(new AminoField<>(CoinValueStr.class, delegation, delegation == null)); fields.add(new AminoField<>(String.class, sideChainId, StringUtils.isEmpty(sideChainId))); fields.add(new AminoField<>(byte[].class, sideConsAddr, sideConsAddr == null || sideConsAddr.length == 0)); fields.add(new AminoField<>(byte[].class, sideFeeAddr, sideFeeAddr == null || sideFeeAddr.length == 0)); @@ -111,27 +117,27 @@ public void setCommission(CommissionMsgValue commission) { this.commission = commission; } - public AddressValue getDelegatorAddr() { + public Bech32AddressValue getDelegatorAddr() { return delegatorAddr; } - public void setDelegatorAddr(AddressValue delegatorAddr) { + public void setDelegatorAddr(Bech32AddressValue delegatorAddr) { this.delegatorAddr = delegatorAddr; } - public AddressValue getValidatorOperatorAddr() { + public Bech32AddressValue getValidatorOperatorAddr() { return validatorOperatorAddr; } - public void setValidatorOperatorAddr(AddressValue validatorOperatorAddr) { + public void setValidatorOperatorAddr(Bech32AddressValue validatorOperatorAddr) { this.validatorOperatorAddr = validatorOperatorAddr; } - public CoinValue getDelegation() { + public CoinValueStr getDelegation() { return delegation; } - public void setDelegation(CoinValue delegation) { + public void setDelegation(CoinValueStr delegation) { this.delegation = delegation; } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/EditSideChainValidatorMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/EditSideChainValidatorMessage.java index 011091e..dbc5fac 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/EditSideChainValidatorMessage.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/EditSideChainValidatorMessage.java @@ -3,11 +3,11 @@ import com.binance.dex.api.client.encoding.amino.AminoField; import com.binance.dex.api.client.encoding.amino.AminoSerializable; import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; -import com.binance.dex.api.client.encoding.message.sidechain.value.AddressValue; -import com.binance.dex.api.client.encoding.message.sidechain.value.Dec; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.encoding.message.common.Dec; import com.binance.dex.api.client.encoding.message.sidechain.value.DescriptionValue; +import com.binance.dex.api.client.encoding.serializer.Bech32AddressValueToStringSerializer; import com.binance.dex.api.client.encoding.serializer.DecToStringSerializer; -import com.binance.dex.api.client.encoding.serializer.ValAddressValueToStringSerializer; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.annotation.JsonPropertyOrder; @@ -27,8 +27,8 @@ public class EditSideChainValidatorMessage implements BinanceDexTransactionMessa private DescriptionValue description; @JsonProperty(value = "address") - @JsonSerialize(using = ValAddressValueToStringSerializer.class) - private AddressValue validatorOperatorAddress; + @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) + private Bech32AddressValue validatorOperatorAddress; @JsonProperty(value = "commission_rate") @JsonSerialize(using = DecToStringSerializer.class) @@ -40,6 +40,29 @@ public class EditSideChainValidatorMessage implements BinanceDexTransactionMessa @JsonProperty(value = "side_fee_addr") private byte[] sideFeeAddr; + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + description = ((DescriptionValue) value); + break; + case 2: + validatorOperatorAddress = ((Bech32AddressValue) value); + break; + case 3: + commissionRate = ((Dec) value); + break; + case 4: + sideChainId = ((String) value); + break; + case 5: + sideFeeAddr = ((byte[]) value); + break; + default: + break; + } + } + public EditSideChainValidatorMessage() { } @@ -51,11 +74,11 @@ public void setDescription(DescriptionValue description) { this.description = description; } - public AddressValue getValidatorOperatorAddress() { + public Bech32AddressValue getValidatorOperatorAddress() { return validatorOperatorAddress; } - public void setValidatorOperatorAddress(AddressValue validatorOperatorAddress) { + public void setValidatorOperatorAddress(Bech32AddressValue validatorOperatorAddress) { this.validatorOperatorAddress = validatorOperatorAddress; } @@ -83,6 +106,11 @@ public void setSideFeeAddr(byte[] sideFeeAddr) { this.sideFeeAddr = sideFeeAddr; } + @Override + public boolean useAminoJson() { + return true; + } + @Override public AminoSerializable newAminoMessage() { return new EditSideChainValidatorMessage(); @@ -92,16 +120,11 @@ public AminoSerializable newAminoMessage() { public ArrayList> IterateFields() { return AminoField.newFieldsBuilder() .addField(DescriptionValue.class, description, description == null) - .addField(AddressValue.class, validatorOperatorAddress, validatorOperatorAddress == null || validatorOperatorAddress.isDefaultOrEmpty()) + .addField(Bech32AddressValue.class, validatorOperatorAddress, validatorOperatorAddress == null || validatorOperatorAddress.isDefaultOrEmpty()) .addField(Dec.class, commissionRate, commissionRate == null || commissionRate.isDefaultOrEmpty()) .addField(String.class, sideChainId, StringUtils.isEmpty(sideChainId)) .addField(byte[].class, sideFeeAddr, sideFeeAddr == null || sideFeeAddr.length == 0) .build(); } - @Override - public void setValueByFieldIndex(int fieldIndex, Object value) { - - } - } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainDelegateMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainDelegateMessage.java index c2f9657..b2c104b 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainDelegateMessage.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainDelegateMessage.java @@ -3,10 +3,9 @@ import com.binance.dex.api.client.encoding.amino.AminoField; import com.binance.dex.api.client.encoding.amino.AminoSerializable; import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; -import com.binance.dex.api.client.encoding.message.sidechain.value.AddressValue; -import com.binance.dex.api.client.encoding.message.sidechain.value.CoinValue; -import com.binance.dex.api.client.encoding.serializer.AccAddressValueToStringSerializer; -import com.binance.dex.api.client.encoding.serializer.ValAddressValueToStringSerializer; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.encoding.message.common.CoinValueStr; +import com.binance.dex.api.client.encoding.serializer.Bech32AddressValueToStringSerializer; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.annotation.JsonPropertyOrder; @@ -23,42 +22,42 @@ public class SideChainDelegateMessage implements BinanceDexTransactionMessage, AminoSerializable { @JsonProperty(value = "delegator_addr") - @JsonSerialize(using = AccAddressValueToStringSerializer.class) - private AddressValue delegatorAddress; + @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) + private Bech32AddressValue delegatorAddress; @JsonProperty(value = "validator_addr") - @JsonSerialize(using = ValAddressValueToStringSerializer.class) - private AddressValue validatorAddress; + @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) + private Bech32AddressValue validatorAddress; @JsonProperty(value = "delegation") - private CoinValue delegation; + private CoinValueStr delegation; @JsonProperty(value = "side_chain_id") private String sideChainId; public SideChainDelegateMessage() { } - public AddressValue getDelegatorAddress() { + public Bech32AddressValue getDelegatorAddress() { return delegatorAddress; } - public void setDelegatorAddress(AddressValue delegatorAddress) { + public void setDelegatorAddress(Bech32AddressValue delegatorAddress) { this.delegatorAddress = delegatorAddress; } - public AddressValue getValidatorAddress() { + public Bech32AddressValue getValidatorAddress() { return validatorAddress; } - public void setValidatorAddress(AddressValue validatorAddress) { + public void setValidatorAddress(Bech32AddressValue validatorAddress) { this.validatorAddress = validatorAddress; } - public CoinValue getDelegation() { + public CoinValueStr getDelegation() { return delegation; } - public void setDelegation(CoinValue delegation) { + public void setDelegation(CoinValueStr delegation) { this.delegation = delegation; } @@ -78,9 +77,9 @@ public AminoSerializable newAminoMessage() { @Override public ArrayList> IterateFields() { return AminoField.newFieldsBuilder() - .addField(AddressValue.class, delegatorAddress, delegatorAddress == null || delegatorAddress.isDefaultOrEmpty()) - .addField(AddressValue.class, validatorAddress, validatorAddress == null || validatorAddress.isDefaultOrEmpty()) - .addField(CoinValue.class, delegation, delegation == null) + .addField(Bech32AddressValue.class, delegatorAddress, delegatorAddress == null || delegatorAddress.isDefaultOrEmpty()) + .addField(Bech32AddressValue.class, validatorAddress, validatorAddress == null || validatorAddress.isDefaultOrEmpty()) + .addField(CoinValueStr.class, delegation, delegation == null) .addField(String.class, sideChainId, StringUtils.isEmpty(sideChainId)) .build(); } @@ -89,13 +88,13 @@ public ArrayList> IterateFields() { public void setValueByFieldIndex(int fieldIndex, Object value) { switch (fieldIndex) { case 1: - delegatorAddress = ((AddressValue) value); + delegatorAddress = ((Bech32AddressValue) value); break; case 2: - validatorAddress = ((AddressValue) value); + validatorAddress = ((Bech32AddressValue) value); break; case 3: - delegation = ((CoinValue) value); + delegation = ((CoinValueStr) value); break; case 4: sideChainId = ((String) value); @@ -105,4 +104,9 @@ public void setValueByFieldIndex(int fieldIndex, Object value) { } } + @Override + public boolean useAminoJson() { + return true; + } + } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainRedelegateMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainRedelegateMessage.java index 44c4e74..b12022d 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainRedelegateMessage.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainRedelegateMessage.java @@ -3,10 +3,9 @@ import com.binance.dex.api.client.encoding.amino.AminoField; import com.binance.dex.api.client.encoding.amino.AminoSerializable; import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; -import com.binance.dex.api.client.encoding.message.sidechain.value.AddressValue; -import com.binance.dex.api.client.encoding.message.sidechain.value.CoinValue; -import com.binance.dex.api.client.encoding.serializer.AccAddressValueToStringSerializer; -import com.binance.dex.api.client.encoding.serializer.ValAddressValueToStringSerializer; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.encoding.message.common.CoinValueStr; +import com.binance.dex.api.client.encoding.serializer.Bech32AddressValueToStringSerializer; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.annotation.JsonPropertyOrder; @@ -23,19 +22,19 @@ public class SideChainRedelegateMessage implements BinanceDexTransactionMessage, AminoSerializable { @JsonProperty(value = "delegator_addr") - @JsonSerialize(using = AccAddressValueToStringSerializer.class) - private AddressValue delegatorAddress; + @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) + private Bech32AddressValue delegatorAddress; @JsonProperty(value = "validator_src_addr") - @JsonSerialize(using = ValAddressValueToStringSerializer.class) - private AddressValue srcValidatorAddress; + @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) + private Bech32AddressValue srcValidatorAddress; @JsonProperty(value = "validator_dst_addr") - @JsonSerialize(using = ValAddressValueToStringSerializer.class) - private AddressValue dstValidatorAddress; + @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) + private Bech32AddressValue dstValidatorAddress; @JsonProperty(value = "amount") - private CoinValue amount; + private CoinValueStr amount; @JsonProperty(value = "side_chain_id") private String sideChainId; @@ -51,10 +50,10 @@ public AminoSerializable newAminoMessage() { @Override public ArrayList> IterateFields() { return AminoField.newFieldsBuilder() - .addField(AddressValue.class, delegatorAddress, delegatorAddress == null || delegatorAddress.isDefaultOrEmpty()) - .addField(AddressValue.class, srcValidatorAddress, srcValidatorAddress == null || srcValidatorAddress.isDefaultOrEmpty()) - .addField(AddressValue.class, dstValidatorAddress, dstValidatorAddress == null || dstValidatorAddress.isDefaultOrEmpty()) - .addField(CoinValue.class, amount, amount == null) + .addField(Bech32AddressValue.class, delegatorAddress, delegatorAddress == null || delegatorAddress.isDefaultOrEmpty()) + .addField(Bech32AddressValue.class, srcValidatorAddress, srcValidatorAddress == null || srcValidatorAddress.isDefaultOrEmpty()) + .addField(Bech32AddressValue.class, dstValidatorAddress, dstValidatorAddress == null || dstValidatorAddress.isDefaultOrEmpty()) + .addField(CoinValueStr.class, amount, amount == null) .addField(String.class, sideChainId, StringUtils.isEmpty(sideChainId)) .build(); } @@ -63,16 +62,16 @@ public ArrayList> IterateFields() { public void setValueByFieldIndex(int fieldIndex, Object value) { switch (fieldIndex) { case 1: - delegatorAddress = ((AddressValue) value); + delegatorAddress = ((Bech32AddressValue) value); break; case 2: - srcValidatorAddress = ((AddressValue) value); + srcValidatorAddress = ((Bech32AddressValue) value); break; case 3: - dstValidatorAddress = ((AddressValue) value); + dstValidatorAddress = ((Bech32AddressValue) value); break; case 4: - amount = ((CoinValue) value); + amount = ((CoinValueStr) value); break; case 5: sideChainId = ((String) value); @@ -82,35 +81,40 @@ public void setValueByFieldIndex(int fieldIndex, Object value) { } } - public AddressValue getDelegatorAddress() { + @Override + public boolean useAminoJson() { + return true; + } + + public Bech32AddressValue getDelegatorAddress() { return delegatorAddress; } - public void setDelegatorAddress(AddressValue delegatorAddress) { + public void setDelegatorAddress(Bech32AddressValue delegatorAddress) { this.delegatorAddress = delegatorAddress; } - public AddressValue getSrcValidatorAddress() { + public Bech32AddressValue getSrcValidatorAddress() { return srcValidatorAddress; } - public void setSrcValidatorAddress(AddressValue srcValidatorAddress) { + public void setSrcValidatorAddress(Bech32AddressValue srcValidatorAddress) { this.srcValidatorAddress = srcValidatorAddress; } - public AddressValue getDstValidatorAddress() { + public Bech32AddressValue getDstValidatorAddress() { return dstValidatorAddress; } - public void setDstValidatorAddress(AddressValue dstValidatorAddress) { + public void setDstValidatorAddress(Bech32AddressValue dstValidatorAddress) { this.dstValidatorAddress = dstValidatorAddress; } - public CoinValue getAmount() { + public CoinValueStr getAmount() { return amount; } - public void setAmount(CoinValue amount) { + public void setAmount(CoinValueStr amount) { this.amount = amount; } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainUndelegateMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainUndelegateMessage.java index f2390f9..996ca39 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainUndelegateMessage.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainUndelegateMessage.java @@ -3,10 +3,9 @@ import com.binance.dex.api.client.encoding.amino.AminoField; import com.binance.dex.api.client.encoding.amino.AminoSerializable; import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; -import com.binance.dex.api.client.encoding.message.sidechain.value.AddressValue; -import com.binance.dex.api.client.encoding.message.sidechain.value.CoinValue; -import com.binance.dex.api.client.encoding.serializer.AccAddressValueToStringSerializer; -import com.binance.dex.api.client.encoding.serializer.ValAddressValueToStringSerializer; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.encoding.message.common.CoinValueStr; +import com.binance.dex.api.client.encoding.serializer.Bech32AddressValueToStringSerializer; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.annotation.JsonPropertyOrder; @@ -23,15 +22,15 @@ public class SideChainUndelegateMessage implements BinanceDexTransactionMessage, AminoSerializable { @JsonProperty(value = "delegator_addr") - @JsonSerialize(using = AccAddressValueToStringSerializer.class) - private AddressValue delegatorAddress; + @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) + private Bech32AddressValue delegatorAddress; @JsonProperty(value = "validator_addr") - @JsonSerialize(using = ValAddressValueToStringSerializer.class) - private AddressValue validatorAddress; + @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) + private Bech32AddressValue validatorAddress; @JsonProperty(value = "amount") - private CoinValue amount; + private CoinValueStr amount; @JsonProperty(value = "side_chain_id") private String sideChainId; @@ -39,6 +38,10 @@ public class SideChainUndelegateMessage implements BinanceDexTransactionMessage, public SideChainUndelegateMessage() { } + @Override + public boolean useAminoJson() { + return true; + } @Override public AminoSerializable newAminoMessage() { @@ -48,9 +51,9 @@ public AminoSerializable newAminoMessage() { @Override public ArrayList> IterateFields() { return AminoField.newFieldsBuilder() - .addField(AddressValue.class, delegatorAddress, delegatorAddress == null || delegatorAddress.isDefaultOrEmpty()) - .addField(AddressValue.class, validatorAddress, validatorAddress == null || validatorAddress.isDefaultOrEmpty()) - .addField(CoinValue.class, amount, amount == null) + .addField(Bech32AddressValue.class, delegatorAddress, delegatorAddress == null || delegatorAddress.isDefaultOrEmpty()) + .addField(Bech32AddressValue.class, validatorAddress, validatorAddress == null || validatorAddress.isDefaultOrEmpty()) + .addField(CoinValueStr.class, amount, amount == null) .addField(String.class, sideChainId, StringUtils.isEmpty(sideChainId)) .build(); } @@ -59,13 +62,13 @@ public ArrayList> IterateFields() { public void setValueByFieldIndex(int fieldIndex, Object value) { switch (fieldIndex) { case 1: - delegatorAddress = ((AddressValue) value); + delegatorAddress = ((Bech32AddressValue) value); break; case 2: - validatorAddress = ((AddressValue) value); + validatorAddress = ((Bech32AddressValue) value); break; case 3: - amount = ((CoinValue) value); + amount = ((CoinValueStr) value); break; case 4: sideChainId = ((String) value); @@ -75,27 +78,27 @@ public void setValueByFieldIndex(int fieldIndex, Object value) { } } - public AddressValue getDelegatorAddress() { + public Bech32AddressValue getDelegatorAddress() { return delegatorAddress; } - public void setDelegatorAddress(AddressValue delegatorAddress) { + public void setDelegatorAddress(Bech32AddressValue delegatorAddress) { this.delegatorAddress = delegatorAddress; } - public AddressValue getValidatorAddress() { + public Bech32AddressValue getValidatorAddress() { return validatorAddress; } - public void setValidatorAddress(AddressValue validatorAddress) { + public void setValidatorAddress(Bech32AddressValue validatorAddress) { this.validatorAddress = validatorAddress; } - public CoinValue getAmount() { + public CoinValueStr getAmount() { return amount; } - public void setAmount(CoinValue amount) { + public void setAmount(CoinValueStr amount) { this.amount = amount; } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/CommissionMsgValue.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/CommissionMsgValue.java index ddeeac1..9cf9aa5 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/CommissionMsgValue.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/CommissionMsgValue.java @@ -2,6 +2,7 @@ import com.binance.dex.api.client.encoding.amino.AminoField; import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.common.Dec; import com.binance.dex.api.client.encoding.serializer.DecToStringSerializer; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/DelegationValue.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/DelegationValue.java index ec607c8..17ceab4 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/DelegationValue.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/DelegationValue.java @@ -2,6 +2,7 @@ import com.binance.dex.api.client.encoding.amino.AminoField; import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.common.Dec; import java.util.ArrayList; diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/RedelegationValue.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/RedelegationValue.java index b3a3240..1ae3822 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/RedelegationValue.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/RedelegationValue.java @@ -2,6 +2,8 @@ import com.binance.dex.api.client.encoding.amino.AminoField; import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.common.CoinValueStr; +import com.binance.dex.api.client.encoding.message.common.Dec; import java.util.ArrayList; @@ -14,9 +16,9 @@ public class RedelegationValue implements AminoSerializable { private TimestampValue minTime = new TimestampValue(); - private CoinValue initialBalance = new CoinValue(); + private CoinValueStr initialBalance = new CoinValueStr(); - private CoinValue balance = new CoinValue(); + private CoinValueStr balance = new CoinValueStr(); private Dec sharesSrc = new Dec(); @@ -41,19 +43,19 @@ public void setMinTime(TimestampValue minTime) { this.minTime = minTime; } - public CoinValue getInitialBalance() { + public CoinValueStr getInitialBalance() { return initialBalance; } - public void setInitialBalance(CoinValue initialBalance) { + public void setInitialBalance(CoinValueStr initialBalance) { this.initialBalance = initialBalance; } - public CoinValue getBalance() { + public CoinValueStr getBalance() { return balance; } - public void setBalance(CoinValue balance) { + public void setBalance(CoinValueStr balance) { this.balance = balance; } @@ -83,8 +85,8 @@ public ArrayList> IterateFields() { return AminoField.newFieldsBuilder() .addField(Long.class, creationHeight, creationHeight == 0) .addField(TimestampValue.class, minTime, minTime == null) - .addField(CoinValue.class, initialBalance, initialBalance == null) - .addField(CoinValue.class, balance, balance == null) + .addField(CoinValueStr.class, initialBalance, initialBalance == null) + .addField(CoinValueStr.class, balance, balance == null) .addField(Dec.class, sharesSrc, sharesSrc == null) .addField(Dec.class, sharesDst, sharesDst == null) .build(); @@ -100,10 +102,10 @@ public void setValueByFieldIndex(int fieldIndex, Object value) { minTime = ((TimestampValue) value); break; case 3: - initialBalance = ((CoinValue) value); + initialBalance = ((CoinValueStr) value); break; case 4: - balance = ((CoinValue) value); + balance = ((CoinValueStr) value); break; case 5: sharesSrc = ((Dec) value); diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/UnBondingValue.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/UnBondingValue.java index f04f485..db2eba8 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/UnBondingValue.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/UnBondingValue.java @@ -2,6 +2,7 @@ import com.binance.dex.api.client.encoding.amino.AminoField; import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.common.CoinValueStr; import java.util.ArrayList; @@ -14,9 +15,9 @@ public class UnBondingValue implements AminoSerializable { private TimestampValue minTime = new TimestampValue(); - private CoinValue initialBalance = new CoinValue(); + private CoinValueStr initialBalance = new CoinValueStr(); - private CoinValue balance = new CoinValue(); + private CoinValueStr balance = new CoinValueStr(); public UnBondingValue() { } @@ -37,19 +38,19 @@ public void setMinTime(TimestampValue minTime) { this.minTime = minTime; } - public CoinValue getInitialBalance() { + public CoinValueStr getInitialBalance() { return initialBalance; } - public void setInitialBalance(CoinValue initialBalance) { + public void setInitialBalance(CoinValueStr initialBalance) { this.initialBalance = initialBalance; } - public CoinValue getBalance() { + public CoinValueStr getBalance() { return balance; } - public void setBalance(CoinValue balance) { + public void setBalance(CoinValueStr balance) { this.balance = balance; } @@ -63,8 +64,8 @@ public ArrayList> IterateFields() { return AminoField.newFieldsBuilder() .addField(Long.class, creationHeight, creationHeight == 0) .addField(TimestampValue.class, minTime, minTime == null) - .addField(CoinValue.class, initialBalance, initialBalance == null) - .addField(CoinValue.class, balance, balance == null) + .addField(CoinValueStr.class, initialBalance, initialBalance == null) + .addField(CoinValueStr.class, balance, balance == null) .build(); } @@ -78,10 +79,10 @@ public void setValueByFieldIndex(int fieldIndex, Object value) { minTime = ((TimestampValue) value); break; case 3: - initialBalance = ((CoinValue) value); + initialBalance = ((CoinValueStr) value); break; case 4: - balance = ((CoinValue) value); + balance = ((CoinValueStr) value); break; default: break; diff --git a/src/main/java/com/binance/dex/api/client/encoding/serializer/AccAddressValueToStringSerializer.java b/src/main/java/com/binance/dex/api/client/encoding/serializer/AccAddressValueToStringSerializer.java deleted file mode 100644 index 5899a6a..0000000 --- a/src/main/java/com/binance/dex/api/client/encoding/serializer/AccAddressValueToStringSerializer.java +++ /dev/null @@ -1,21 +0,0 @@ -package com.binance.dex.api.client.encoding.serializer; - -import com.binance.dex.api.client.encoding.message.sidechain.value.AddressValue; -import com.fasterxml.jackson.core.JsonGenerator; -import com.fasterxml.jackson.databind.JsonSerializer; -import com.fasterxml.jackson.databind.SerializerProvider; - -import java.io.IOException; - -/** - * @author Fitz.Lu - **/ -public class AccAddressValueToStringSerializer extends JsonSerializer { - - @Override - public void serialize(AddressValue addressValue, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { - if (addressValue != null && addressValue.getAddress() != null){ - jsonGenerator.writeString(addressValue.getAddress()); - } - } -} \ No newline at end of file diff --git a/src/main/java/com/binance/dex/api/client/encoding/serializer/Bech32AddressValueToStringSerializer.java b/src/main/java/com/binance/dex/api/client/encoding/serializer/Bech32AddressValueToStringSerializer.java new file mode 100644 index 0000000..a39981d --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/serializer/Bech32AddressValueToStringSerializer.java @@ -0,0 +1,22 @@ +package com.binance.dex.api.client.encoding.serializer; + +import com.binance.dex.api.client.encoding.Crypto; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.databind.JsonSerializer; +import com.fasterxml.jackson.databind.SerializerProvider; + +import java.io.IOException; + +/** + * @author Fitz.Lu + **/ +public class Bech32AddressValueToStringSerializer extends JsonSerializer { + + @Override + public void serialize(Bech32AddressValue addressValue, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { + if (addressValue != null && addressValue.getHrp() != null && addressValue.getRaw() != null){ + jsonGenerator.writeString(Crypto.encodeAddress(addressValue.getHrp(), addressValue.getRaw())); + } + } +} \ No newline at end of file diff --git a/src/main/java/com/binance/dex/api/client/encoding/serializer/DecToStringSerializer.java b/src/main/java/com/binance/dex/api/client/encoding/serializer/DecToStringSerializer.java index 6f489c9..92a478e 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/serializer/DecToStringSerializer.java +++ b/src/main/java/com/binance/dex/api/client/encoding/serializer/DecToStringSerializer.java @@ -1,6 +1,6 @@ package com.binance.dex.api.client.encoding.serializer; -import com.binance.dex.api.client.encoding.message.sidechain.value.Dec; +import com.binance.dex.api.client.encoding.message.common.Dec; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.JsonSerializer; import com.fasterxml.jackson.databind.SerializerProvider; diff --git a/src/main/java/com/binance/dex/api/client/encoding/serializer/EthAddressValueToStringSerializer.java b/src/main/java/com/binance/dex/api/client/encoding/serializer/EthAddressValueToStringSerializer.java new file mode 100644 index 0000000..cda4cae --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/serializer/EthAddressValueToStringSerializer.java @@ -0,0 +1,20 @@ +package com.binance.dex.api.client.encoding.serializer; + +import com.binance.dex.api.client.encoding.message.common.EthAddressValue; +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.databind.JsonSerializer; +import com.fasterxml.jackson.databind.SerializerProvider; + +import java.io.IOException; + +/** + * @author Fitz.Lu + **/ +public class EthAddressValueToStringSerializer extends JsonSerializer { + @Override + public void serialize(EthAddressValue ethAddressValue, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { + if (ethAddressValue != null && ethAddressValue.getAddress() != null){ + jsonGenerator.writeString(ethAddressValue.getAddress()); + } + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/serializer/ValAddressValueToStringSerializer.java b/src/main/java/com/binance/dex/api/client/encoding/serializer/ValAddressValueToStringSerializer.java deleted file mode 100644 index 810ed37..0000000 --- a/src/main/java/com/binance/dex/api/client/encoding/serializer/ValAddressValueToStringSerializer.java +++ /dev/null @@ -1,23 +0,0 @@ -package com.binance.dex.api.client.encoding.serializer; - -import com.binance.dex.api.client.encoding.Bech32; -import com.binance.dex.api.client.encoding.message.sidechain.value.AddressValue; -import com.fasterxml.jackson.core.JsonGenerator; -import com.fasterxml.jackson.databind.JsonSerializer; -import com.fasterxml.jackson.databind.SerializerProvider; - -import java.io.IOException; - -/** - * @author Fitz.Lu - **/ -public class ValAddressValueToStringSerializer extends JsonSerializer { - - @Override - public void serialize(AddressValue addressValue, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { - if (addressValue != null && addressValue.getAddress() != null){ - Bech32.Bech32Data bech32Data = Bech32.decode(addressValue.getAddress()); - jsonGenerator.writeString(Bech32.encode("bva", bech32Data.getData())); - } - } -} diff --git a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java index 32356bf..c1875a8 100644 --- a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java +++ b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java @@ -2,20 +2,21 @@ import com.binance.dex.api.client.*; import com.binance.dex.api.client.domain.*; -import com.binance.dex.api.client.domain.sidechain.*; +import com.binance.dex.api.client.domain.bridge.TransferIn; +import com.binance.dex.api.client.domain.oracle.Prophecy; import com.binance.dex.api.client.domain.StakeValidator; -import com.binance.dex.api.client.domain.sidechain.CreateSideChainValidator; -import com.binance.dex.api.client.domain.sidechain.EditSideChainValidator; +import com.binance.dex.api.client.domain.stake.Pool; +import com.binance.dex.api.client.domain.stake.sidechain.*; import com.binance.dex.api.client.domain.broadcast.Transaction; import com.binance.dex.api.client.domain.broadcast.*; import com.binance.dex.api.client.domain.jsonrpc.*; -import com.binance.dex.api.client.domain.sidechain.SideChainDelegate; -import com.binance.dex.api.client.domain.sidechain.SideChainRedelegate; -import com.binance.dex.api.client.domain.sidechain.SideChainUnBond; -import com.binance.dex.api.client.domain.sidechain.SideChainValidator; import com.binance.dex.api.client.encoding.Crypto; import com.binance.dex.api.client.encoding.EncodeUtils; import com.binance.dex.api.client.encoding.message.TransactionRequestAssembler; +import com.binance.dex.api.client.impl.node.NodeQueryDelegateOracle; +import com.binance.dex.api.client.impl.node.NodeQueryDelegateSideChainStaking; +import com.binance.dex.api.client.impl.node.NodeTxDelegateBridge; +import com.binance.dex.api.client.impl.node.NodeTxDelegateSideChainStaking; import com.binance.dex.api.proto.*; import com.binance.dex.api.proto.Token; import com.google.common.collect.Lists; @@ -39,6 +40,8 @@ public class BinanceDexApiNodeClientImpl implements BinanceDexApiNodeClient { private String hrp; + private String valHrp; + private TransactionConverter transactionConverter; private FeeConverter feeConverter; @@ -49,15 +52,25 @@ public class BinanceDexApiNodeClientImpl implements BinanceDexApiNodeClient { private final static int TX_SEARCH_PERPAGE = 10000; - private final BinanceDexApiNodeClientImplSideChainQueryDelegate sideChainQueryDelegate; + private final NodeTxDelegateSideChainStaking sideChainStakingTxDelegate; + + private final NodeTxDelegateBridge bridgeTxDelegate; + + private final NodeQueryDelegateSideChainStaking sideChainQueryDelegate; - public BinanceDexApiNodeClientImpl(String nodeUrl, String hrp) { + private final NodeQueryDelegateOracle oracleQueryDelegate; + + public BinanceDexApiNodeClientImpl(String nodeUrl, String hrp, String valHrp) { this.binanceDexNodeApi = BinanceDexApiClientGenerator.createService(BinanceDexNodeApi.class, nodeUrl); this.hrp = hrp; - transactionConverter = new TransactionConverter(hrp); + this.valHrp = valHrp; + transactionConverter = new TransactionConverter(hrp, valHrp); feeConverter = new FeeConverter(); - sideChainQueryDelegate = new BinanceDexApiNodeClientImplSideChainQueryDelegate(binanceDexNodeApi); + sideChainStakingTxDelegate = new NodeTxDelegateSideChainStaking(binanceDexNodeApi, hrp, valHrp); + bridgeTxDelegate = new NodeTxDelegateBridge(binanceDexNodeApi, hrp, valHrp); + sideChainQueryDelegate = new NodeQueryDelegateSideChainStaking(binanceDexNodeApi, hrp, valHrp); + oracleQueryDelegate = new NodeQueryDelegateOracle(binanceDexNodeApi, hrp, valHrp); } @Override @@ -97,11 +110,11 @@ public List getFees() { @Override public Account getAccount(String address) { try { - String queryPath = String.format("\"/account/%s\"",address); + String queryPath = String.format("\"/account/%s\"", address); JsonRpcResponse response = BinanceDexApiClientGenerator.executeSync(binanceDexNodeApi.getAccount(queryPath)); checkRpcResult(response); byte[] value = response.getResult().getResponse().getValue(); - if(value != null && value.length > 0){ + if (value != null && value.length > 0) { byte[] array = new byte[value.length - 4]; System.arraycopy(value, 4, array, 0, array.length); AppAccount account = AppAccount.parseFrom(array); @@ -120,7 +133,7 @@ public Account getCommittedAccount(String address) { JsonRpcResponse response = BinanceDexApiClientGenerator.executeSync(binanceDexNodeApi.getCommittedAccount(encodedAddress)); checkRpcResult(response); byte[] value = response.getResult().getResponse().getValue(); - if(value != null && value.length > 0){ + if (value != null && value.length > 0) { byte[] array = new byte[value.length - 4]; System.arraycopy(value, 4, array, 0, array.length); AppAccount account = AppAccount.parseFrom(array); @@ -133,7 +146,7 @@ public Account getCommittedAccount(String address) { } @Override - public AtomicSwap getSwapByID(String swapID){ + public AtomicSwap getSwapByID(String swapID) { try { Map.Entry swapIdEntry = Maps.immutableEntry("SwapID", swapID); String requestData = "0x" + Hex.toHexString(EncodeUtils.toJsonStringSortKeys(swapIdEntry).getBytes()); @@ -156,7 +169,7 @@ public AtomicSwap getSwapByID(String swapID){ @Override public List getBlockTransactions(Long height) { JsonRpcResponse response = BinanceDexApiClientGenerator.executeSync(binanceDexNodeApi - .getBlockTransactions("\"tx.height=" + height.toString() + "\"",TX_SEARCH_PAGE,TX_SEARCH_PERPAGE)); + .getBlockTransactions("\"tx.height=" + height.toString() + "\"", TX_SEARCH_PAGE, TX_SEARCH_PERPAGE)); checkRpcResult(response); return response.getResult().getTxs().stream() .map(transactionConverter::convert) @@ -189,7 +202,7 @@ public Transaction getTransaction(String hash) { transactions.get(0).setHash(transactionResult.getHash()); transactions.get(0).setCode(transactionResult.getTxResult().getCode()); transactions.get(0).setLog(transactionResult.getTxResult().getLog()); - transactionConverter.fillTagsAndEvents(transactionResult.getTxResult(),transactions.get(0)); + transactionConverter.fillTagsAndEvents(transactionResult.getTxResult(), transactions.get(0)); return transactions.get(0); } @@ -315,7 +328,7 @@ public List depositHtlt(String swapId, List claimHtlt(String swapId, byte[] randomNumber, W synchronized (wallet) { wallet.ensureWalletIsReady(this); TransactionRequestAssembler assembler = new TransactionRequestAssembler(wallet, options); - String requestPayload = "0x" + assembler.buildClaimHtltPayload(swapId,randomNumber); + String requestPayload = "0x" + assembler.buildClaimHtltPayload(swapId, randomNumber); if (sync) { return syncBroadcast(requestPayload, wallet); } else { @@ -356,13 +369,7 @@ public List refundHtlt(String swapId, Wallet wallet, Transa public List createSideChainValidator(CreateSideChainValidator createSideChainValidator, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { synchronized (wallet) { wallet.ensureWalletIsReady(this); - TransactionRequestAssembler assembler = new TransactionRequestAssembler(wallet, options); - String requestPayload = "0x" + assembler.buildCreateSideChainValidatorPayload(createSideChainValidator); - if (sync) { - return syncBroadcast(requestPayload, wallet); - } else { - return asyncBroadcast(requestPayload, wallet); - } + return sideChainStakingTxDelegate.createSideChainValidator(createSideChainValidator, wallet, options, sync); } } @@ -370,13 +377,7 @@ public List createSideChainValidator(CreateSideChainValidat public List editSideChainValidator(EditSideChainValidator editSideChainValidator, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { synchronized (wallet) { wallet.ensureWalletIsReady(this); - TransactionRequestAssembler assembler = new TransactionRequestAssembler(wallet, options); - String requestPayload = "0x" + assembler.buildEditSideChainValidatorPayload(editSideChainValidator); - if (sync) { - return syncBroadcast(requestPayload, wallet); - } else { - return asyncBroadcast(requestPayload, wallet); - } + return sideChainStakingTxDelegate.editSideChainValidator(editSideChainValidator, wallet, options, sync); } } @@ -384,13 +385,7 @@ public List editSideChainValidator(EditSideChainValidator e public List sideChainDelegate(SideChainDelegate sideChainDelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { synchronized (wallet) { wallet.ensureWalletIsReady(this); - TransactionRequestAssembler assembler = new TransactionRequestAssembler(wallet, options); - String requestPayload = "0x" + assembler.buildSideChainDelegatePayload(sideChainDelegate); - if (sync) { - return syncBroadcast(requestPayload, wallet); - } else { - return asyncBroadcast(requestPayload, wallet); - } + return sideChainStakingTxDelegate.sideChainDelegate(sideChainDelegate, wallet, options, sync); } } @@ -398,13 +393,7 @@ public List sideChainDelegate(SideChainDelegate sideChainDe public List sideChainRedelagate(SideChainRedelegate sideChainRedelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { synchronized (wallet) { wallet.ensureWalletIsReady(this); - TransactionRequestAssembler assembler = new TransactionRequestAssembler(wallet, options); - String requestPayload = "0x" + assembler.buildSideChainRedelegatePayload(sideChainRedelegate); - if (sync) { - return syncBroadcast(requestPayload, wallet); - } else { - return asyncBroadcast(requestPayload, wallet); - } + return sideChainStakingTxDelegate.sideChainRedelagate(sideChainRedelegate, wallet, options, sync); } } @@ -412,18 +401,12 @@ public List sideChainRedelagate(SideChainRedelegate sideCha public List sideChainUnbond(SideChainUnBond sideChainUndelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { synchronized (wallet) { wallet.ensureWalletIsReady(this); - TransactionRequestAssembler assembler = new TransactionRequestAssembler(wallet, options); - String requestPayload = "0x" + assembler.buildSideChainUndelegatePayload(sideChainUndelegate); - if (sync) { - return syncBroadcast(requestPayload, wallet); - } else { - return asyncBroadcast(requestPayload, wallet); - } + return sideChainStakingTxDelegate.sideChainUnbond(sideChainUndelegate, wallet, options, sync); } } @Override - public SideChainValidator getSideChainValidator(String sideChainId, byte[] validatorAddress) throws IOException { + public SideChainValidator getSideChainValidator(String sideChainId, String validatorAddress) throws IOException { return sideChainQueryDelegate.querySideChainValidator(sideChainId, validatorAddress); } @@ -433,35 +416,113 @@ public List getSideChainTopValidators(String sideChainId, in } @Override - public SideChainDelegation getSideChainDelegation(String sideChainId, byte[] delegatorAddress, byte[] validatorAddress) throws IOException { + public SideChainDelegation getSideChainDelegation(String sideChainId, String delegatorAddress, String validatorAddress) throws IOException { return sideChainQueryDelegate.querySideChainDelegation(sideChainId, delegatorAddress, validatorAddress); } @Override - public List getSideChainDelegations(String sideChainId, byte[] delegatorAddress) throws IOException { + public List getSideChainDelegations(String sideChainId, String delegatorAddress) throws IOException { return sideChainQueryDelegate.querySideChainDelegations(sideChainId, delegatorAddress); } @Override - public SideChainRedelegation getSideChainRedelegation(String sideChainId, byte[] delegatorAddress, byte[] srcValidatorAddress, byte[] dstValidatorAddress) throws IOException { + public SideChainRedelegation getSideChainRedelegation(String sideChainId, String delegatorAddress, String srcValidatorAddress, String dstValidatorAddress) throws IOException { return sideChainQueryDelegate.querySideChainRedelegation(sideChainId, delegatorAddress, srcValidatorAddress, dstValidatorAddress); } @Override - public List getSideChainRedelegations(String sideChainId, byte[] delegatorAddress) throws IOException { + public List getSideChainRedelegations(String sideChainId, String delegatorAddress) throws IOException { return sideChainQueryDelegate.querySideChainRedelegations(sideChainId, delegatorAddress); } @Override - public SideChainUnBondingDelegation getSideChainUnBondingDelegation(String sideChainId, byte[] delegatorAddress, byte[] validatorAddress) throws IOException { + public UnBondingDelegation getSideChainUnBondingDelegation(String sideChainId, String delegatorAddress, String validatorAddress) throws IOException { return sideChainQueryDelegate.querySideChainUnBondingDelegation(sideChainId, delegatorAddress, validatorAddress); } @Override - public List getSideChainUnBondingDelegations(String sideChainId, byte[] delegatorAddress) throws IOException { + public List getSideChainUnBondingDelegations(String sideChainId, String delegatorAddress) throws IOException { return sideChainQueryDelegate.querySideChainUnBondingDelegations(sideChainId, delegatorAddress); } + @Override + public List getSideChainUnBondingDelegationsByValidator(String sideChainId, String validatorAddress) throws IOException{ + return sideChainQueryDelegate.querySideChainUnBondingDelegationsByValidator(sideChainId, validatorAddress); + } + + @Override + public List getSideChainRedelegationsByValidator(String sideChainId, String validatorAddress) throws IOException { + return sideChainQueryDelegate.querySideChainRedelegationsByValidator(sideChainId, validatorAddress); + } + + @Override + public Pool getSideChainPool(String sideChainId) throws IOException { + return sideChainQueryDelegate.querySideChainPool(sideChainId); + } + + @Override + public long getAllSideChainValidatorsCount(String sideChainId, boolean jailInvolved) throws IOException { + return sideChainQueryDelegate.queryAllSideChainValidatorsCount(sideChainId, jailInvolved); + } + + @Override + public List transferIn(long sequence, TransferIn transferIn, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + synchronized (wallet) { + wallet.ensureWalletIsReady(this); + return bridgeTxDelegate.transferIn(sequence, transferIn, wallet, options, sync); + } + } + + @Override + public List transferOut(String toAddress, com.binance.dex.api.client.encoding.message.Token amount, long expireTimeInSeconds, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + synchronized (wallet) { + wallet.ensureWalletIsReady(this); + return bridgeTxDelegate.transferOut(toAddress, amount, expireTimeInSeconds, wallet, options, sync); + } + } + + @Override + public List bind(String symbol, long amount, String contractAddress, int contractDecimal, long expireTimeInSeconds, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + synchronized (wallet) { + wallet.ensureWalletIsReady(this); + return bridgeTxDelegate.bind(symbol, amount, contractAddress, contractDecimal, expireTimeInSeconds, wallet, options, sync); + } + } + + @Override + public List updateTransferOut(long sequence, String refundAddress, com.binance.dex.api.client.encoding.message.Token amount, int refundReason, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + synchronized (wallet) { + wallet.ensureWalletIsReady(this); + return bridgeTxDelegate.updateTransferOut(sequence, refundAddress, amount, refundReason, wallet, options, sync); + } + } + + @Override + public List updateBind(long sequence, String symbol, String contractAddress, int status, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + synchronized (wallet) { + wallet.ensureWalletIsReady(this); + return bridgeTxDelegate.updateBind(sequence, symbol, contractAddress, status, wallet, options, sync); + } + } + + @Override + public List claim(int claimType, String claim, long sequence, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + synchronized (wallet) { + wallet.ensureWalletIsReady(this); + return bridgeTxDelegate.claim(claimType, claim, sequence, wallet, options, sync); + } + } + + @Override + public Prophecy getProphecy(int claimType, long sequence) throws IOException { + return oracleQueryDelegate.getProphecy(claimType, sequence); + } + + @Override + public long getCurrentSequence(int claimType) { + return oracleQueryDelegate.getCurrentSequence(claimType); + } + @Override public List broadcast(String payload, boolean sync) { payload = "0x" + payload; diff --git a/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegate.java b/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegate.java new file mode 100644 index 0000000..ea92518 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegate.java @@ -0,0 +1,107 @@ +package com.binance.dex.api.client.impl.node; + +import com.binance.dex.api.client.BinanceDexApiClientGenerator; +import com.binance.dex.api.client.BinanceDexApiError; +import com.binance.dex.api.client.BinanceDexApiException; +import com.binance.dex.api.client.BinanceDexNodeApi; +import com.binance.dex.api.client.domain.jsonrpc.ABCIQueryResult; +import com.binance.dex.api.client.domain.jsonrpc.JsonRpcResponse; +import com.binance.dex.api.client.encoding.ByteUtil; +import com.google.protobuf.CodedInputStream; +import com.google.protobuf.InvalidProtocolBufferException; +import common.Types; +import org.bouncycastle.util.encoders.Hex; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; + +/** + * @author Fitz.Lu + **/ +class NodeQueryDelegate { + + private final BinanceDexNodeApi binanceDexNodeApi; + + protected final String hrp; + + protected final String valHrp; + + public NodeQueryDelegate(BinanceDexNodeApi binanceDexNodeApi, String hrp, String valHrp) { + this.binanceDexNodeApi = binanceDexNodeApi; + this.hrp = hrp; + this.valHrp = valHrp; + } + + protected byte[] queryWithData(String path, byte[] data){ + String d = "0x" + Hex.toHexString(data); + JsonRpcResponse rpcResponse = BinanceDexApiClientGenerator.executeSync(binanceDexNodeApi.abciQuery(path, d)); + checkABCIResponse(rpcResponse); + + return rpcResponse.getResult().getResponse().getValue(); + } + + protected byte[] queryStore(String storeName, byte[] key){ + String keyHex = "0x" + Hex.toHexString(key); + String path = String.format("\"/store/%s/%s\"", storeName, "key"); + JsonRpcResponse rpcResponse = BinanceDexApiClientGenerator.executeSync(binanceDexNodeApi.abciQuery(path, keyHex)); + checkABCIResponse(rpcResponse); + + return rpcResponse.getResult().getResponse().getValue(); + } + + protected byte[] queryStoreSubspace(String storeName, byte[] key){ + String keyHex = "0x" + Hex.toHexString(key); + String path = String.format("\"/store/%s/subspace\"", storeName); + JsonRpcResponse rpcResponse = BinanceDexApiClientGenerator.executeSync(binanceDexNodeApi.abciQuery(path, keyHex)); + checkABCIResponse(rpcResponse); + + return rpcResponse.getResult().getResponse().getValue(); + } + + protected List queryStoreSubspaceKVPairs(String storeName, byte[] key) throws IOException { + String keyHex = "0x" + Hex.toHexString(key); + String path = String.format("\"/store/%s/subspace\"", storeName); + JsonRpcResponse rpcResponse = BinanceDexApiClientGenerator.executeSync(binanceDexNodeApi.abciQuery(path, keyHex)); + checkABCIResponse(rpcResponse); + + byte[] result = rpcResponse.getResult().getResponse().getValue(); + + if (!ByteUtil.isEmpty(result)) { + try { + CodedInputStream codedInputStream = CodedInputStream.newInstance(result); + + if (codedInputStream.isAtEnd()){ + return new ArrayList<>(); + } + //read length prefix + int length = codedInputStream.readRawVarint32(); + if (length == 0){ + return new ArrayList<>(); + } + + types.Types.KVPairs kvPairs = types.Types.KVPairs.parseFrom(codedInputStream); + + return kvPairs.getPairsList(); + }catch (InvalidProtocolBufferException e){ + throw new IOException("Decode response failed due to: " + e.getMessage()); + } + }else{ + return new ArrayList<>(); + } + } + + protected void checkABCIResponse(JsonRpcResponse rpcResponse) { + if (null != rpcResponse.getError() && null != rpcResponse.getError().getCode()) { + throw new RuntimeException(rpcResponse.getError().toString()); + } + ABCIQueryResult.Response response = rpcResponse.getResult().getResponse(); + if (response.getCode() != null) { + BinanceDexApiError binanceDexApiError = new BinanceDexApiError(); + binanceDexApiError.setCode(response.getCode()); + binanceDexApiError.setMessage(response.getLog()); + throw new BinanceDexApiException(binanceDexApiError); + } + } + +} diff --git a/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegateOracle.java b/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegateOracle.java new file mode 100644 index 0000000..eb19164 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegateOracle.java @@ -0,0 +1,91 @@ +package com.binance.dex.api.client.impl.node; + +import com.binance.dex.api.client.BinanceDexNodeApi; +import com.binance.dex.api.client.domain.oracle.Prophecy; +import com.binance.dex.api.client.domain.oracle.Status; +import com.binance.dex.api.client.encoding.Bech32; +import com.binance.dex.api.client.encoding.ByteUtil; +import com.binance.dex.api.client.encoding.EncodeUtils; +import com.binance.dex.api.client.encoding.amino.Amino; +import com.binance.dex.api.client.encoding.message.bridge.DBProphecy; +import com.fasterxml.jackson.core.type.TypeReference; +import com.google.common.base.Charsets; + +import javax.annotation.Nullable; +import java.io.IOException; +import java.nio.ByteOrder; +import java.util.HashMap; +import java.util.Map; + +/** + * @author Fitz.Lu + **/ +public class NodeQueryDelegateOracle extends NodeQueryDelegate { + + private static final String oracleStoreName = "oracle"; + + private static final String claimTypeSequencePrefix = "claimTypeSeq:"; + + private static final Amino amino = new Amino(); + + public NodeQueryDelegateOracle(BinanceDexNodeApi binanceDexNodeApi, String hrp, String valHrp) { + super(binanceDexNodeApi, hrp, valHrp); + } + + @Nullable + public Prophecy getProphecy(int claimType, long sequence) throws IOException { + byte[] key = getClaimId(claimType, sequence).getBytes(Charsets.UTF_8); + byte[] result = queryStore(oracleStoreName, key); + + if (!ByteUtil.isEmpty(result)){ + DBProphecy prophecy = new DBProphecy(); + amino.decodeBare(result, prophecy); + return convert(prophecy); + } + + return null; + } + + public long getCurrentSequence(int claimType){ + byte[] key = getClaimTypeSequence(claimType); + byte[] result = queryStore(oracleStoreName, key); + if (!ByteUtil.isEmpty(result)){ + return java.nio.ByteBuffer.wrap(result).order(ByteOrder.BIG_ENDIAN).getLong(); + } + + return 0; + } + + private Prophecy convert(DBProphecy dbProphecy) throws IOException { + Prophecy prophecy = new Prophecy(); + HashMap validatorClaims; + validatorClaims = EncodeUtils.getObjectMapper().readValue(new String(dbProphecy.getValidatorClaims()), new TypeReference>(){}); + + HashMap claimValidators = new HashMap<>(); + for (Map.Entry entry : validatorClaims.entrySet()) { + claimValidators.put(entry.getValue(), Bech32.decode(entry.getKey()).getData()); + } + + prophecy.setId(dbProphecy.getId()); + + Status status = new Status(); + if (dbProphecy.getStatus() != null){ + status.setText(dbProphecy.getStatus().getText()); + status.setFinalClaim(dbProphecy.getStatus().getFinalClaim()); + } + prophecy.setStatus(status); + prophecy.setValidatorClaims(validatorClaims); + prophecy.setClaimValidators(claimValidators); + + return prophecy; + } + + private String getClaimId(int claimType, long sequence) { + return String.format("%d:%d", claimType, sequence); + } + + private byte[] getClaimTypeSequence(int claimType){ + return ByteUtil.appendBytesArray(claimTypeSequencePrefix.getBytes(Charsets.UTF_8), new byte[]{((byte) claimType)}); + } + +} diff --git a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImplSideChainQueryDelegate.java b/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegateSideChainStaking.java similarity index 58% rename from src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImplSideChainQueryDelegate.java rename to src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegateSideChainStaking.java index 1e45fba..c37b79c 100644 --- a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImplSideChainQueryDelegate.java +++ b/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegateSideChainStaking.java @@ -1,27 +1,27 @@ -package com.binance.dex.api.client.impl; +package com.binance.dex.api.client.impl.node; import com.binance.dex.api.client.*; -import com.binance.dex.api.client.domain.jsonrpc.ABCIQueryResult; -import com.binance.dex.api.client.domain.jsonrpc.JsonRpcResponse; -import com.binance.dex.api.client.domain.sidechain.*; +import com.binance.dex.api.client.domain.stake.Commission; +import com.binance.dex.api.client.domain.stake.Description; +import com.binance.dex.api.client.domain.stake.Pool; +import com.binance.dex.api.client.domain.stake.sidechain.*; import com.binance.dex.api.client.encoding.ByteUtil; +import com.binance.dex.api.client.encoding.Crypto; import com.binance.dex.api.client.encoding.EncodeUtils; import com.binance.dex.api.client.encoding.amino.Amino; import com.binance.dex.api.client.encoding.amino.WireType; -import com.binance.dex.api.client.encoding.message.sidechain.query.BechValidator; -import com.binance.dex.api.client.encoding.message.sidechain.query.QueryTopValidatorParams; -import com.binance.dex.api.client.encoding.message.sidechain.query.SideChainValidatorMessage; +import com.binance.dex.api.client.encoding.message.Token; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.encoding.message.common.CoinValue; +import com.binance.dex.api.client.encoding.message.sidechain.query.*; import com.binance.dex.api.client.encoding.message.sidechain.value.DelegationValue; import com.binance.dex.api.client.encoding.message.sidechain.value.RedelegationValue; import com.binance.dex.api.client.encoding.message.sidechain.value.UnBondingValue; import com.fasterxml.jackson.core.type.TypeReference; import com.google.common.base.Charsets; -import com.google.protobuf.CodedInputStream; -import com.google.protobuf.InvalidProtocolBufferException; -import org.bouncycastle.util.encoders.Hex; -import types.Types; import java.io.IOException; +import java.nio.ByteBuffer; import java.nio.charset.Charset; import java.util.ArrayList; import java.util.Arrays; @@ -30,7 +30,7 @@ /** * @author Fitz.Lu **/ -class BinanceDexApiNodeClientImplSideChainQueryDelegate { +public class NodeQueryDelegateSideChainStaking extends NodeQueryDelegate { private final String stakeStoreName = "stake"; private final String scStoreKey = "sc"; @@ -42,25 +42,24 @@ class BinanceDexApiNodeClientImplSideChainQueryDelegate { private final byte[] delegationKey = new byte[]{0x31}; private final byte[] redelegationKey = new byte[]{0x34}; private final byte[] unBondingDelegationKey = new byte[]{0x32}; + private final byte[] poolKey = new byte[]{0x01}; private final Charset defaultCharset = Charsets.UTF_8; - private final BinanceDexNodeApi binanceDexNodeApi; - private final Amino amino; - BinanceDexApiNodeClientImplSideChainQueryDelegate(BinanceDexNodeApi binanceDexNodeApi) { - this.binanceDexNodeApi = binanceDexNodeApi; - this.amino = new Amino(); + public NodeQueryDelegateSideChainStaking(BinanceDexNodeApi binanceDexNodeApi, String hrp, String valHrp) { + super(binanceDexNodeApi, hrp, valHrp); + amino = new Amino(); } - SideChainValidator querySideChainValidator(String sideChainId, byte[] validatorAddress) throws IOException { + public SideChainValidator querySideChainValidator(String sideChainId, String validatorAddress) throws IOException { byte[] storePrefix = getSideChainStorePrefixKey(sideChainId); byte[] keyPrefix = queryStore(stakeStoreName, storePrefix); if (keyPrefix == null) { keyPrefix = new byte[0]; } - byte[] key = ByteUtil.appendBytesArray(keyPrefix, getValidatorKey(validatorAddress)); + byte[] key = ByteUtil.appendBytesArray(keyPrefix, getValidatorKey(Crypto.decodeAddress(validatorAddress))); byte[] result = queryStore(stakeStoreName, key); if (result != null) { @@ -72,7 +71,7 @@ SideChainValidator querySideChainValidator(String sideChainId, byte[] validatorA } } - List querySideChainTopValidators(String sideChainId, int top) throws IOException { + public List querySideChainTopValidators(String sideChainId, int top) throws IOException { if (top > 50 || top < 1){ throw new IllegalArgumentException("top must be between 1 and 50"); } @@ -101,8 +100,12 @@ List querySideChainTopValidators(String sideChainId, int top private SideChainValidator convert(SideChainValidatorMessage message){ SideChainValidator sideChainValidator = new SideChainValidator(); - sideChainValidator.setFeeAddr(message.getFeeAddr()); - sideChainValidator.setOperatorAddr(message.getOperatorAddr()); + if (message.getFeeAddr() != null) { + sideChainValidator.setFeeAddr(Crypto.encodeEthAddress(message.getFeeAddr())); + } + if (message.getOperatorAddr() != null) { + sideChainValidator.setOperatorAddr(Crypto.encodeAddress(valHrp, message.getOperatorAddr())); + } //TODO consPubKey use amino decode with type prefix boolean fallBack = true; @@ -119,6 +122,10 @@ private SideChainValidator convert(SideChainValidatorMessage message){ sideChainValidator.setConsPubKey(message.getConsPubKey()); } + if (message.getDistributionAddr() != null){ + sideChainValidator.setDistributionAddr(Crypto.encodeAddress(hrp, message.getDistributionAddr())); + } + sideChainValidator.setJailed(message.isJailed()); sideChainValidator.setStatus(message.getStatus()); sideChainValidator.setTokens(message.getTokens().getValue()); @@ -147,15 +154,20 @@ private SideChainValidator convert(SideChainValidatorMessage message){ sideChainValidator.setCommission(commission); sideChainValidator.setSideChainId(message.getSideChainId()); - sideChainValidator.setSideConsAddr(message.getSideConsAddr()); - sideChainValidator.setSideFeeAddr(message.getSideFeeAddr()); + + if (message.getSideConsAddr() != null) { + sideChainValidator.setSideConsAddr(Crypto.encodeEthAddress(message.getSideConsAddr())); + } + if (message.getSideFeeAddr() != null) { + sideChainValidator.setSideFeeAddr(Crypto.encodeEthAddress(message.getSideFeeAddr())); + } return sideChainValidator; } - SideChainDelegation querySideChainDelegation(String sideChainId, byte[] delegatorAddress, byte[] validatorAddress) throws IOException { + public SideChainDelegation querySideChainDelegation(String sideChainId, String delegatorAddress, String validatorAddress) throws IOException { byte[] storePrefix = getSideChainStorePrefixKey(sideChainId); - byte[] delegationKey = getDelegationKey(delegatorAddress, validatorAddress); + byte[] delegationKey = getDelegationKey(Crypto.decodeAddress(delegatorAddress), Crypto.decodeAddress(validatorAddress)); byte[] key = ByteUtil.appendBytesArray(storePrefix, delegationKey); byte[] result = queryStore(stakeStoreName, key); @@ -169,9 +181,9 @@ SideChainDelegation querySideChainDelegation(String sideChainId, byte[] delegato return null; } - List querySideChainDelegations(String sideChainId, byte[] delegatorAddress) throws IOException { + public List querySideChainDelegations(String sideChainId, String delegatorAddress) throws IOException { byte[] storePrefix = getSideChainStorePrefixKey(sideChainId); - byte[] key = ByteUtil.appendBytesArray(storePrefix, getDelegationsKey(delegatorAddress)); + byte[] key = ByteUtil.appendBytesArray(storePrefix, getDelegationsKey(Crypto.decodeAddress(delegatorAddress))); List kvPairs = queryStoreSubspaceKVPairs(stakeStoreName, key); List delegations = new ArrayList<>(); @@ -195,8 +207,8 @@ private SideChainDelegation convert(DelegationValue delegationValue, byte[] key) System.arraycopy(key, addressLength, valAddress, 0, addressLength); SideChainDelegation sideChainDelegation = new SideChainDelegation(); - sideChainDelegation.setDelegatorAddress(delAddress); - sideChainDelegation.setValidatorAddress(valAddress); + sideChainDelegation.setDelegatorAddress(Crypto.encodeAddress(hrp, delAddress)); + sideChainDelegation.setValidatorAddress(Crypto.encodeAddress(valHrp, valAddress)); sideChainDelegation.setHeight(delegationValue.getHeight()); if (delegationValue.getShares() != null) { sideChainDelegation.setShares(delegationValue.getShares().getValue()); @@ -205,9 +217,10 @@ private SideChainDelegation convert(DelegationValue delegationValue, byte[] key) return sideChainDelegation; } - SideChainRedelegation querySideChainRedelegation(String sideChainId, byte[] delegatorAddress, byte[] srcValidatorAddress, byte[] dstValidatorAddress) throws IOException { + public SideChainRedelegation querySideChainRedelegation(String sideChainId, String delegatorAddress, String srcValidatorAddress, String dstValidatorAddress) throws IOException { byte[] storePrefix = getSideChainStorePrefixKey(sideChainId); - byte[] redKey = getRedelegationKey(delegatorAddress, srcValidatorAddress, dstValidatorAddress); + byte[] redKey = getRedelegationKey(Crypto.decodeAddress(delegatorAddress), Crypto.decodeAddress(srcValidatorAddress), + Crypto.decodeAddress(dstValidatorAddress)); byte[] key = ByteUtil.appendBytesArray(storePrefix, redKey); byte[] result = queryStore(stakeStoreName, key); @@ -220,9 +233,9 @@ SideChainRedelegation querySideChainRedelegation(String sideChainId, byte[] dele return null; } - List querySideChainRedelegations(String sideChainId, byte[] delegatorAddress) throws IOException { + public List querySideChainRedelegations(String sideChainId, String delegatorAddress) throws IOException { byte[] storePrefix = getSideChainStorePrefixKey(sideChainId); - byte[] redsKey = getRedelegationsKey(delegatorAddress); + byte[] redsKey = getRedelegationsKey(Crypto.decodeAddress(delegatorAddress)); byte[] key = ByteUtil.appendBytesArray(storePrefix, redsKey); List result = queryStoreSubspaceKVPairs(stakeStoreName, key); List redelegations = new ArrayList<>(); @@ -244,9 +257,9 @@ private SideChainRedelegation convert(RedelegationValue value, byte[] key){ throw new IllegalStateException("unexpected address length for (address, srcValidator, dstValidator)"); } - byte[] delAddr = ByteUtil.pick(addresses, 0, addressLength); - byte[] srcValAddr = ByteUtil.pick(addresses, addressLength, addressLength); - byte[] dstValAddr = ByteUtil.pick(addresses, addressLength * 2, addressLength); + String delAddr = Crypto.encodeAddress(hrp, ByteUtil.pick(addresses, 0, addressLength)); + String srcValAddr = Crypto.encodeAddress(valHrp, ByteUtil.pick(addresses, addressLength, addressLength)); + String dstValAddr = Crypto.encodeAddress(valHrp, ByteUtil.pick(addresses, addressLength * 2, addressLength)); SideChainRedelegation redelegation = new SideChainRedelegation(); redelegation.setDelegatorAddress(delAddr); @@ -275,9 +288,9 @@ private SideChainRedelegation convert(RedelegationValue value, byte[] key){ return redelegation; } - SideChainUnBondingDelegation querySideChainUnBondingDelegation(String sideChainId, byte[] delegatorAddress, byte[] validatorAddress) throws IOException { + public UnBondingDelegation querySideChainUnBondingDelegation(String sideChainId, String delegatorAddress, String validatorAddress) throws IOException { byte[] storePrefix = getSideChainStorePrefixKey(sideChainId); - byte[] ubdKey = getUnBondingDelegationKey(delegatorAddress, validatorAddress); + byte[] ubdKey = getUnBondingDelegationKey(Crypto.decodeAddress(delegatorAddress), Crypto.decodeAddress(validatorAddress)); byte[] key = ByteUtil.appendBytesArray(storePrefix, ubdKey); byte[] result = queryStore(stakeStoreName, key); if (!ByteUtil.isEmpty(result)) { @@ -289,12 +302,12 @@ SideChainUnBondingDelegation querySideChainUnBondingDelegation(String sideChainI } } - List querySideChainUnBondingDelegations(String sideChainId, byte[] delegatorAddress) throws IOException { + public List querySideChainUnBondingDelegations(String sideChainId, String delegatorAddress) throws IOException { byte[] storePrefix = getSideChainStorePrefixKey(sideChainId); - byte[] ubdsKey = getUnBondingDelegationsKey(delegatorAddress); + byte[] ubdsKey = getUnBondingDelegationsKey(Crypto.decodeAddress(delegatorAddress)); byte[] key = ByteUtil.appendBytesArray(storePrefix, ubdsKey); List kvPairs = queryStoreSubspaceKVPairs(stakeStoreName, key); - List unBondingDelegations = new ArrayList<>(); + List unBondingDelegations = new ArrayList<>(); if (kvPairs != null && !kvPairs.isEmpty()){ for (common.Types.KVPair kvPair : kvPairs) { UnBondingValue unBondingValue = new UnBondingValue(); @@ -306,14 +319,133 @@ List querySideChainUnBondingDelegations(String sid return unBondingDelegations; } - private SideChainUnBondingDelegation convert(UnBondingValue value, byte[] addresses){ + public List querySideChainUnBondingDelegationsByValidator(String sideChainId, String validatorAddress) throws IOException { + QueryValidatorParams params = new QueryValidatorParams(sideChainId, Bech32AddressValue.fromBech32StringWithNewHrp(validatorAddress, valHrp)); + byte[] data = EncodeUtils.toJsonEncodeBytes(params); + byte[] result = queryWithData("\"custom/stake/validatorUnbondingDelegations\"", data); + + List unBondingDelegations = new ArrayList<>(); + + if (!ByteUtil.isEmpty(result)){ + List messages = EncodeUtils.getObjectMapper().readValue(result, new TypeReference>(){}); + if (messages != null && !messages.isEmpty()){ + for (UnBondingDelegationMessage message : messages) { + unBondingDelegations.add(convert(message)); + } + } + } + + return unBondingDelegations; + } + + public List querySideChainRedelegationsByValidator(String sideChainId, String validatorAddress) throws IOException { + QueryValidatorParams params = new QueryValidatorParams(sideChainId, Bech32AddressValue.fromBech32StringWithNewHrp(validatorAddress, valHrp)); + byte[] data = EncodeUtils.toJsonEncodeBytes(params); + byte[] result = queryWithData("\"custom/stake/validatorRedelegations\"", data); + + List redelegations = new ArrayList<>(); + + if (!ByteUtil.isEmpty(result)){ + List messages = EncodeUtils.getObjectMapper().readValue(result, new TypeReference>(){}); + if (messages != null && !messages.isEmpty()){ + for (SideChainRedelegationMessage message : messages) { + redelegations.add(convert(message)); + } + } + } + + return redelegations; + } + + public Pool querySideChainPool(String sideChainId) throws IOException { + byte[] storePrefix = getSideChainStorePrefixKey(sideChainId); + byte[] key = ByteUtil.appendBytesArray(storePrefix, poolKey); + byte[] result = queryStore(stakeStoreName, key); + + if (!ByteUtil.isEmpty(result)){ + PoolMessage message = new PoolMessage(); + amino.decodeWithLengthPrefix(result, message); + + Pool pool = new Pool(); + if (message.getLooseTokens() != null){ + pool.setLooseTokens(message.getLooseTokens().getValue()); + } + if (message.getBondedTokens() != null){ + pool.setBondedTokens(message.getBondedTokens().getValue()); + } + + return pool; + } + + return null; + } + + public long queryAllSideChainValidatorsCount(String sideChainId, boolean jailInvolved) throws IOException { + BaseQueryParams params = new BaseQueryParams(); + params.setSideChainId(sideChainId); + byte[] data = EncodeUtils.toJsonEncodeBytes(params); + String path = "\"custom/stake/allUnJailValidatorsCount\""; + if (jailInvolved){ + path = "\"custom/stake/allValidatorsCount\""; + } + byte[] result = queryWithData(path, data); + if (!ByteUtil.isEmpty(result)){ + String count = new String(result); + if (count.contains("\"")){ + count = count.replaceAll("\"", ""); + } + return Long.parseLong(count); + } + + return 0L; + } + + private SideChainRedelegation convert(SideChainRedelegationMessage message){ + SideChainRedelegation redelegation = new SideChainRedelegation(); + redelegation.setDelegatorAddress(message.getDelegatorAddress()); + redelegation.setSrcValidatorAddress(message.getSrcValidatorAddress()); + redelegation.setDstValidatorAddress(message.getDstValidatorAddress()); + redelegation.setCreateHeight(message.getCreateHeight()); + redelegation.setMinTime(message.getMinTime()); + if (message.getInitialBalance() != null) { + redelegation.setInitialBalance(convert(message.getInitialBalance())); + } + if (message.getBalance() != null){ + redelegation.setBalance(convert(message.getBalance())); + } + redelegation.setSrcShares(message.getSrcShares()); + redelegation.setDstShare(message.getDstShare()); + + return redelegation; + } + + private Token convert(CoinValue coinValue){ + Token token = new Token(); + token.setDenom(coinValue.getDenom()); + token.setAmount(coinValue.getAmount()); + return token; + } + + private UnBondingDelegation convert(UnBondingDelegationMessage message){ + UnBondingDelegation unBondingDelegation = new UnBondingDelegation(); + unBondingDelegation.setBalance(message.getBalance()); + unBondingDelegation.setCreateHeight(message.getCreateHeight()); + unBondingDelegation.setDelegatorAddress(message.getDelegatorAddress()); + unBondingDelegation.setValidatorAddress(message.getValidatorAddress()); + unBondingDelegation.setInitialBalance(message.getInitialBalance()); + unBondingDelegation.setMinTime(message.getMinTime()); + + return unBondingDelegation; + } + + private UnBondingDelegation convert(UnBondingValue value, byte[] addresses){ if (addresses.length != addressLength * 2){ throw new IllegalStateException("unexpected address length for this (address, validator) pair"); } - SideChainUnBondingDelegation unBondingDelegation = new SideChainUnBondingDelegation(); - unBondingDelegation.setDelegatorAddress(ByteUtil.pick(addresses, 0, addressLength)); - unBondingDelegation.setValidatorAddress(ByteUtil.pick(addresses, addressLength, addressLength)); + UnBondingDelegation unBondingDelegation = new UnBondingDelegation(); + unBondingDelegation.setDelegatorAddress(Crypto.encodeAddress(hrp, ByteUtil.pick(addresses, 0, addressLength))); + unBondingDelegation.setValidatorAddress(Crypto.encodeAddress(hrp, ByteUtil.pick(addresses, addressLength, addressLength))); unBondingDelegation.setCreateHeight(value.getCreationHeight()); if (value.getMinTime() != null){ unBondingDelegation.setMinTimeInMs(value.getMinTime().getTimeInMilliseconds()); @@ -375,75 +507,4 @@ byte[] getUnBondingDelegationsKey(byte[] delegatorAddress){ return ByteUtil.appendBytesArray(unBondingDelegationKey, delegatorAddress); } - private byte[] queryWithData(String path, byte[] data){ - String d = "0x" + Hex.toHexString(data); - JsonRpcResponse rpcResponse = BinanceDexApiClientGenerator.executeSync(binanceDexNodeApi.abciQuery(path, d)); - checkABCIResponse(rpcResponse); - - return rpcResponse.getResult().getResponse().getValue(); - } - - private byte[] queryStore(String storeName, byte[] key){ - String keyHex = "0x" + Hex.toHexString(key); - String path = String.format("\"/store/%s/%s\"", storeName, "key"); - JsonRpcResponse rpcResponse = BinanceDexApiClientGenerator.executeSync(binanceDexNodeApi.abciQuery(path, keyHex)); - checkABCIResponse(rpcResponse); - - return rpcResponse.getResult().getResponse().getValue(); - } - - private byte[] queryStoreSubspace(String storeName, byte[] key){ - String keyHex = "0x" + Hex.toHexString(key); - String path = String.format("\"/store/%s/subspace\"", storeName); - JsonRpcResponse rpcResponse = BinanceDexApiClientGenerator.executeSync(binanceDexNodeApi.abciQuery(path, keyHex)); - checkABCIResponse(rpcResponse); - - return rpcResponse.getResult().getResponse().getValue(); - } - - private List queryStoreSubspaceKVPairs(String storeName, byte[] key) throws IOException { - String keyHex = "0x" + Hex.toHexString(key); - String path = String.format("\"/store/%s/subspace\"", storeName); - JsonRpcResponse rpcResponse = BinanceDexApiClientGenerator.executeSync(binanceDexNodeApi.abciQuery(path, keyHex)); - checkABCIResponse(rpcResponse); - - byte[] result = rpcResponse.getResult().getResponse().getValue(); - - if (!ByteUtil.isEmpty(result)) { - try { - CodedInputStream codedInputStream = CodedInputStream.newInstance(result); - - if (codedInputStream.isAtEnd()){ - return new ArrayList<>(); - } - //read length prefix - int length = codedInputStream.readRawVarint32(); - if (length == 0){ - return new ArrayList<>(); - } - - Types.KVPairs kvPairs = Types.KVPairs.parseFrom(codedInputStream); - - return kvPairs.getPairsList(); - }catch (InvalidProtocolBufferException e){ - throw new IOException("Decode response failed due to: " + e.getMessage()); - } - }else{ - return new ArrayList<>(); - } - } - - private void checkABCIResponse(JsonRpcResponse rpcResponse) { - if (null != rpcResponse.getError() && null != rpcResponse.getError().getCode() && rpcResponse.getError().getCode().intValue() != 0) { - throw new RuntimeException(rpcResponse.getError().toString()); - } - ABCIQueryResult.Response response = rpcResponse.getResult().getResponse(); - if (response.getCode() != null) { - BinanceDexApiError binanceDexApiError = new BinanceDexApiError(); - binanceDexApiError.setCode(response.getCode()); - binanceDexApiError.setMessage(response.getLog()); - throw new BinanceDexApiException(binanceDexApiError); - } - } - } diff --git a/src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegate.java b/src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegate.java new file mode 100644 index 0000000..a96d11a --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegate.java @@ -0,0 +1,146 @@ +package com.binance.dex.api.client.impl.node; + +import com.binance.dex.api.client.BinanceDexApiClientGenerator; +import com.binance.dex.api.client.BinanceDexApiException; +import com.binance.dex.api.client.BinanceDexNodeApi; +import com.binance.dex.api.client.Wallet; +import com.binance.dex.api.client.domain.TransactionMetadata; +import com.binance.dex.api.client.domain.broadcast.TransactionOption; +import com.binance.dex.api.client.domain.jsonrpc.AsyncBroadcastResult; +import com.binance.dex.api.client.domain.jsonrpc.CommitBroadcastResult; +import com.binance.dex.api.client.domain.jsonrpc.JsonRpcResponse; +import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; +import com.binance.dex.api.client.encoding.message.TransactionRequestAssembler; +import com.google.common.collect.Lists; +import org.apache.commons.lang3.StringUtils; + +import java.io.IOException; +import java.security.NoSuchAlgorithmException; +import java.util.List; + +/** + * @author Fitz.Lu + **/ +class NodeTxDelegate { + + protected final BinanceDexNodeApi binanceDexNodeApi; + + protected final String hrp; + + protected final String valHrp; + + NodeTxDelegate(BinanceDexNodeApi binanceDexNodeApi, String hrp, String valHrp){ + this.binanceDexNodeApi = binanceDexNodeApi; + this.hrp = hrp; + this.valHrp = valHrp; + } + + protected List broadcast(BinanceDexTransactionMessage message, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + message.validateBasic(); + TransactionRequestAssembler assembler = new TransactionRequestAssembler(wallet, options); + String requestPayload = "0x" + assembler.buildTxPayload(message); + if (sync) { + return syncBroadcast(requestPayload, wallet); + } else { + return asyncBroadcast(requestPayload, wallet); + } + } + + protected List syncBroadcast(String requestBody, Wallet wallet) { + try { + JsonRpcResponse rpcResponse = BinanceDexApiClientGenerator.executeSync(binanceDexNodeApi.commitBroadcast(requestBody)); + CommitBroadcastResult commitBroadcastResult = rpcResponse.getResult(); + TransactionMetadata transactionMetadata = new TransactionMetadata(); + transactionMetadata.setCode(commitBroadcastResult.getCheckTx().getCode()); + if (commitBroadcastResult.getHeight() != null && StringUtils.isNoneBlank(commitBroadcastResult.getHash()) && transactionMetadata.getCode() == 0) { + wallet.increaseAccountSequence(); + transactionMetadata.setHash(commitBroadcastResult.getHash()); + transactionMetadata.setHeight(commitBroadcastResult.getHeight()); + transactionMetadata.setLog(commitBroadcastResult.getCheckTx().getLog()); + transactionMetadata.setOk(true); + } else { + wallet.invalidAccountSequence(); + transactionMetadata.setLog(commitBroadcastResult.getCheckTx().getLog()); + transactionMetadata.setOk(false); + } + + return Lists.newArrayList(transactionMetadata); + } catch (BinanceDexApiException e) { + wallet.invalidAccountSequence(); + throw new RuntimeException(e); + } + } + + protected List syncBroadcast(String requestBody) { + try { + JsonRpcResponse rpcResponse = BinanceDexApiClientGenerator.executeSync(binanceDexNodeApi.commitBroadcast(requestBody)); + CommitBroadcastResult commitBroadcastResult = rpcResponse.getResult(); + TransactionMetadata transactionMetadata = new TransactionMetadata(); + transactionMetadata.setCode(commitBroadcastResult.getCheckTx().getCode()); + if (commitBroadcastResult.getHeight() != null && StringUtils.isNoneBlank(commitBroadcastResult.getHash()) && transactionMetadata.getCode() == 0) { + transactionMetadata.setHash(commitBroadcastResult.getHash()); + transactionMetadata.setHeight(commitBroadcastResult.getHeight()); + transactionMetadata.setLog(commitBroadcastResult.getCheckTx().getLog()); + transactionMetadata.setOk(true); + } else { + transactionMetadata.setLog(commitBroadcastResult.getCheckTx().getLog()); + transactionMetadata.setOk(false); + } + + return Lists.newArrayList(transactionMetadata); + } catch (BinanceDexApiException e) { + throw new RuntimeException(e); + } + } + + protected List asyncBroadcast(String requestBody) { + try { + JsonRpcResponse rpcResponse = BinanceDexApiClientGenerator.executeSync(binanceDexNodeApi.asyncBroadcast(requestBody)); + AsyncBroadcastResult asyncBroadcastResult = rpcResponse.getResult(); + TransactionMetadata transactionMetadata = new TransactionMetadata(); + + transactionMetadata.setCode(asyncBroadcastResult.getCode()); + transactionMetadata.setLog(asyncBroadcastResult.getLog()); + + if (asyncBroadcastResult.getCode() == 0) { + transactionMetadata.setHash(asyncBroadcastResult.getHash()); + transactionMetadata.setData(asyncBroadcastResult.getData()); + transactionMetadata.setOk(true); + } else { + transactionMetadata.setOk(false); + } + + return Lists.newArrayList(transactionMetadata); + } catch (BinanceDexApiException e) { + throw new RuntimeException(e); + } + } + + + protected List asyncBroadcast(String requestBody, Wallet wallet) { + try { + JsonRpcResponse rpcResponse = BinanceDexApiClientGenerator.executeSync(binanceDexNodeApi.asyncBroadcast(requestBody)); + AsyncBroadcastResult asyncBroadcastResult = rpcResponse.getResult(); + TransactionMetadata transactionMetadata = new TransactionMetadata(); + + transactionMetadata.setCode(asyncBroadcastResult.getCode()); + transactionMetadata.setLog(asyncBroadcastResult.getLog()); + + if (asyncBroadcastResult.getCode() == 0) { + wallet.increaseAccountSequence(); + transactionMetadata.setHash(asyncBroadcastResult.getHash()); + transactionMetadata.setData(asyncBroadcastResult.getData()); + transactionMetadata.setOk(true); + } else { + wallet.invalidAccountSequence(); + transactionMetadata.setOk(false); + } + + return Lists.newArrayList(transactionMetadata); + } catch (BinanceDexApiException e) { + wallet.invalidAccountSequence(); + throw new RuntimeException(e); + } + } + +} diff --git a/src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegateBridge.java b/src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegateBridge.java new file mode 100644 index 0000000..6103f7a --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegateBridge.java @@ -0,0 +1,119 @@ +package com.binance.dex.api.client.impl.node; + +import com.binance.dex.api.client.BinanceDexNodeApi; +import com.binance.dex.api.client.Wallet; +import com.binance.dex.api.client.domain.TransactionMetadata; +import com.binance.dex.api.client.domain.bridge.TransferIn; +import com.binance.dex.api.client.domain.broadcast.TransactionOption; +import com.binance.dex.api.client.encoding.EncodeUtils; +import com.binance.dex.api.client.encoding.message.Token; +import com.binance.dex.api.client.encoding.message.common.CoinValue; +import com.binance.dex.api.client.encoding.message.common.EthAddressValue; +import com.binance.dex.api.client.encoding.message.bridge.*; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; + +import java.io.IOException; +import java.security.NoSuchAlgorithmException; +import java.util.List; + +/** + * @author Fitz.Lu + **/ +public class NodeTxDelegateBridge extends NodeTxDelegate { + + public NodeTxDelegateBridge(BinanceDexNodeApi binanceDexNodeApi, String hrp, String valHrp) { + super(binanceDexNodeApi, hrp, valHrp); + } + + public List claim(int claimType, String claim, long sequence, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + ClaimMsgMessage message = new ClaimMsgMessage(); + message.setClaimType(claimType); + message.setSequence(sequence); + message.setClaim(claim); + message.setValidatorAddress(Bech32AddressValue.fromBech32String(wallet.getAddress())); + + return broadcast(message, wallet, options, sync); + } + + public List transferIn(long sequence, TransferIn transferIn, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + TransferInClaimMessage message = convert(transferIn); + String claim = EncodeUtils.getObjectMapper().writeValueAsString(message); + ClaimMsgMessage claimMsg = new ClaimMsgMessage(ClaimTypes.ClaimTypeTransferIn, sequence, claim, Bech32AddressValue.fromBech32String(wallet.getAddress())); + + return broadcast(claimMsg, wallet, options, sync); + } + + public List transferOut(String toAddress, Token amount, long expireTimeInSeconds, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + TransferOutMsgMessage message = new TransferOutMsgMessage(); + message.setFrom(Bech32AddressValue.fromBech32String(wallet.getAddress())); + message.setToAddress(EthAddressValue.from(toAddress)); + message.setAmount(convert(amount)); + message.setExpireTime(expireTimeInSeconds); + + return broadcast(message, wallet, options, sync); + } + + public List bind(String symbol, long amount, String contractAddress, int contractDecimal, long expireTimeInSeconds, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + BindMsgMessage message = new BindMsgMessage(); + message.setFrom(Bech32AddressValue.fromBech32String(wallet.getAddress())); + message.setSymbol(symbol); + message.setAmount(amount); + message.setContractAddress(EthAddressValue.from(contractAddress)); + message.setContractDecimal(contractDecimal); + message.setExpireTime(expireTimeInSeconds); + + return broadcast(message, wallet, options, sync); + } + + public List updateTransferOut(long sequence, String refundAddress, Token amount, int refundReason, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + UpdateTransferOutClaimMessage message = new UpdateTransferOutClaimMessage(); + message.setAmount(convert(amount)); + message.setRefundAddress(Bech32AddressValue.fromBech32String(refundAddress)); + message.setRefundReason(refundReason); + + ClaimMsgMessage claimMsg = new ClaimMsgMessage(ClaimTypes.ClaimTypeUpdateTransferOut, sequence, + EncodeUtils.getObjectMapper().writeValueAsString(message), Bech32AddressValue.fromBech32String(wallet.getAddress())); + + return broadcast(claimMsg, wallet, options, sync); + } + + public List updateBind(long sequence, String symbol, String contractAddress, int status, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + UpdateBindClaimMessage message = new UpdateBindClaimMessage(); + message.setStatus(status); + message.setSymbol(symbol); + message.setContractAddress(EthAddressValue.from(contractAddress)); + + ClaimMsgMessage claimMsg = new ClaimMsgMessage(ClaimTypes.ClaimTypeUpdateBind, sequence, + EncodeUtils.getObjectMapper().writeValueAsString(message), Bech32AddressValue.fromBech32String(wallet.getAddress())); + + return broadcast(claimMsg, wallet, options, sync); + } + + private CoinValue convert(Token token){ + CoinValue value = new CoinValue(); + value.setDenom(token.getDenom()); + value.setAmount(token.getAmount()); + return value; + } + + private TransferInClaimMessage convert(TransferIn transferIn){ + TransferInClaimMessage message = new TransferInClaimMessage(); + message.setContractAddress(transferIn.getContractAddress()); + message.setRefundAddresses(transferIn.getRefundAddresses()); + message.setReceiverAddresses(transferIn.getReceiverAddresses()); + message.setAmounts(transferIn.getAmounts()); + message.setSymbol(transferIn.getSymbol()); + + CoinValue coinValue = new CoinValue(); + if (transferIn.getRelayFee() != null){ + coinValue.setDenom(transferIn.getRelayFee().getDenom()); + coinValue.setAmount(transferIn.getRelayFee().getAmount()); + } + message.setRelayFee(coinValue); + + message.setExpireTime(transferIn.getExpireTime()); + + return message; + } + +} diff --git a/src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegateSideChainStaking.java b/src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegateSideChainStaking.java new file mode 100644 index 0000000..ea5e80b --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegateSideChainStaking.java @@ -0,0 +1,175 @@ +package com.binance.dex.api.client.impl.node; + +import com.binance.dex.api.client.BinanceDexNodeApi; +import com.binance.dex.api.client.Wallet; +import com.binance.dex.api.client.domain.TransactionMetadata; +import com.binance.dex.api.client.domain.broadcast.TransactionOption; +import com.binance.dex.api.client.domain.stake.Commission; +import com.binance.dex.api.client.domain.stake.Description; +import com.binance.dex.api.client.domain.stake.sidechain.*; +import com.binance.dex.api.client.encoding.message.Token; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.encoding.message.common.CoinValueStr; +import com.binance.dex.api.client.encoding.message.common.Dec; +import com.binance.dex.api.client.encoding.message.sidechain.transaction.*; +import com.binance.dex.api.client.encoding.message.sidechain.value.*; +import com.google.common.annotations.VisibleForTesting; +import org.apache.commons.lang3.StringUtils; +import org.bouncycastle.util.encoders.Hex; + +import java.io.IOException; +import java.security.NoSuchAlgorithmException; +import java.util.List; + +/** + * @author Fitz.Lu + **/ +public class NodeTxDelegateSideChainStaking extends NodeTxDelegate { + + public NodeTxDelegateSideChainStaking(BinanceDexNodeApi binanceDexNodeApi, String hrp, String valHrp) { + super(binanceDexNodeApi, hrp, valHrp); + } + + public List createSideChainValidator(CreateSideChainValidator createSideChainValidator, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + CreateSideChainValidatorMessage message = convert(createSideChainValidator); + if (StringUtils.isEmpty(createSideChainValidator.getValidatorAddr())) { + message.setValidatorOperatorAddr(Bech32AddressValue.fromBech32StringWithNewHrp(wallet.getAddress(), valHrp)); + }else{ + message.setValidatorOperatorAddr(Bech32AddressValue.fromBech32StringWithNewHrp(createSideChainValidator.getValidatorAddr(), valHrp)); + } + return broadcast(message, wallet, options, sync); + } + + public List editSideChainValidator(EditSideChainValidator editSideChainValidator, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + EditSideChainValidatorMessage message = convert(editSideChainValidator); + if (StringUtils.isEmpty(editSideChainValidator.getValidatorAddress())) { + message.setValidatorOperatorAddress(Bech32AddressValue.fromBech32StringWithNewHrp(wallet.getAddress(), valHrp)); + }else{ + message.setValidatorOperatorAddress(Bech32AddressValue.fromBech32StringWithNewHrp(editSideChainValidator.getValidatorAddress(), valHrp)); + } + return broadcast(message, wallet, options, sync); + } + + public List sideChainDelegate(SideChainDelegate sideChainDelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + SideChainDelegateMessage message = convert(sideChainDelegate); + return broadcast(message, wallet, options, sync); + } + + public List sideChainRedelagate(SideChainRedelegate sideChainRedelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + SideChainRedelegateMessage message = convert(sideChainRedelegate); + return broadcast(message, wallet, options, sync); + } + + public List sideChainUnbond(SideChainUnBond sideChainUndelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + SideChainUndelegateMessage message = convert(sideChainUndelegate); + return broadcast(message, wallet, options, sync); + } + + @VisibleForTesting + CreateSideChainValidatorMessage convert(CreateSideChainValidator createSideChainValidator){ + CreateSideChainValidatorMessage message = new CreateSideChainValidatorMessage(); + + if (createSideChainValidator.getDescription() != null){ + message.setDescription(convert(createSideChainValidator.getDescription())); + } + if (createSideChainValidator.getCommission() != null){ + message.setCommission(convert(createSideChainValidator.getCommission())); + } + + message.setDelegatorAddr(Bech32AddressValue.fromBech32String(createSideChainValidator.getDelegatorAddr())); + + if (createSideChainValidator.getDelegation() != null){ + message.setDelegation(convert(createSideChainValidator.getDelegation())); + } + + message.setSideChainId(createSideChainValidator.getSideChainId()); + message.setSideConsAddr(decodeHexAddress(createSideChainValidator.getSideConsAddr())); + message.setSideFeeAddr(decodeHexAddress(createSideChainValidator.getSideFeeAddr())); + return message; + } + + @VisibleForTesting + EditSideChainValidatorMessage convert(EditSideChainValidator editSideChainValidator){ + EditSideChainValidatorMessage message = new EditSideChainValidatorMessage(); + + if (editSideChainValidator.getDescription() != null){ + message.setDescription(convert(editSideChainValidator.getDescription())); + } + + message.setCommissionRate(Dec.newInstance(editSideChainValidator.getCommissionRate())); + message.setSideChainId(editSideChainValidator.getSideChainId()); + message.setSideFeeAddr(decodeHexAddress(editSideChainValidator.getSideFeeAddr())); + + return message; + } + + private byte[] decodeHexAddress(String address){ + String addr = address; + if (addr.startsWith("0x")){ + addr = address.substring(2); + } + return Hex.decode(addr); + } + + private DescriptionValue convert(Description description){ + DescriptionValue value = new DescriptionValue(); + value.setMoniker(description.getMoniker()); + value.setDetails(description.getDetails()); + value.setIdentity(description.getIdentity()); + value.setWebsite(description.getWebsite()); + return value; + } + + private CommissionMsgValue convert(Commission commission){ + CommissionMsgValue value = new CommissionMsgValue(); + value.setRate(Dec.newInstance(commission.getRate())); + value.setMaxRate(Dec.newInstance(commission.getMaxRate())); + value.setMaxChangeRate(Dec.newInstance(commission.getMaxChangeRate())); + return value; + } + + private CoinValueStr convert(Token token){ + CoinValueStr value = new CoinValueStr(); + value.setDenom(token.getDenom()); + value.setAmount(token.getAmount()); + return value; + } + + private SideChainDelegateMessage convert(SideChainDelegate sideChainDelegate){ + SideChainDelegateMessage message = new SideChainDelegateMessage(); + message.setDelegatorAddress(Bech32AddressValue.fromBech32String(sideChainDelegate.getDelegatorAddress())); + message.setValidatorAddress(Bech32AddressValue.fromBech32StringWithNewHrp(sideChainDelegate.getValidatorAddress(), valHrp)); + + if (sideChainDelegate.getDelegation() != null) { + message.setDelegation(convert(sideChainDelegate.getDelegation())); + } + + message.setSideChainId(sideChainDelegate.getSideChainId()); + return message; + } + + private SideChainRedelegateMessage convert(SideChainRedelegate redelegate){ + SideChainRedelegateMessage message = new SideChainRedelegateMessage(); + message.setDelegatorAddress(Bech32AddressValue.fromBech32String(redelegate.getDelegatorAddress())); + message.setSrcValidatorAddress(Bech32AddressValue.fromBech32StringWithNewHrp(redelegate.getSrcValidatorAddress(), valHrp)); + message.setDstValidatorAddress(Bech32AddressValue.fromBech32StringWithNewHrp(redelegate.getDstValidatorAddress(), valHrp)); + if (redelegate.getAmount() != null) { + message.setAmount(convert(redelegate.getAmount())); + } + message.setSideChainId(redelegate.getSideChainId()); + return message; + } + + private SideChainUndelegateMessage convert(SideChainUnBond unBond){ + SideChainUndelegateMessage message = new SideChainUndelegateMessage(); + message.setDelegatorAddress(Bech32AddressValue.fromBech32String(unBond.getDelegatorAddress())); + message.setValidatorAddress(Bech32AddressValue.fromBech32StringWithNewHrp(unBond.getValidatorAddress(), valHrp)); + if (unBond.getAmount() != null) { + message.setAmount(convert(unBond.getAmount())); + } + message.setSideChainId(unBond.getSideChainId()); + return message; + } + + +} diff --git a/src/main/java/com/binance/dex/api/client/websocket/BinanceDexClientWSFactory.java b/src/main/java/com/binance/dex/api/client/websocket/BinanceDexClientWSFactory.java index 8d4d267..ddb3c80 100644 --- a/src/main/java/com/binance/dex/api/client/websocket/BinanceDexClientWSFactory.java +++ b/src/main/java/com/binance/dex/api/client/websocket/BinanceDexClientWSFactory.java @@ -32,12 +32,12 @@ public static BinanceDexWSApiImpl getWSApiImpl(BinanceDexEnvironment env){ } return binanceDexWSApiImplMap.get(env.getWsBaseUrl()); } - public static BinanceDexWSApiImpl getWSApiImpl(String url,String hrp){ + public static BinanceDexWSApiImpl getWSApiImpl(String url,String hrp, String valHrp){ synchronized (lock){ binanceDexWSApiImplMap.computeIfAbsent(url,(k)->{ BinanceDexClientEndpoint endpoint = newDefaultClientEndpoint(url); WebsocketLauncher.startUp(endpoint); - return new BinanceDexWSApiImpl(hrp,endpoint); + return new BinanceDexWSApiImpl(hrp, valHrp, endpoint); }); } return binanceDexWSApiImplMap.get(url); diff --git a/src/main/java/com/binance/dex/api/client/websocket/BinanceDexWSApiImpl.java b/src/main/java/com/binance/dex/api/client/websocket/BinanceDexWSApiImpl.java index 3551f54..37dbe74 100644 --- a/src/main/java/com/binance/dex/api/client/websocket/BinanceDexWSApiImpl.java +++ b/src/main/java/com/binance/dex/api/client/websocket/BinanceDexWSApiImpl.java @@ -37,12 +37,12 @@ public class BinanceDexWSApiImpl extends IdGenerator implements BinanceDexWSApi BinanceDexWSApiImpl(BinanceDexEnvironment env,BinanceDexClientEndpoint endpoint){ this.endpoint = endpoint; - this.transactionConverter = new TransactionConverter(env.getHrp()); + this.transactionConverter = new TransactionConverter(env.getHrp(), env.getValHrp()); } - BinanceDexWSApiImpl(String hrp,BinanceDexClientEndpoint endpoint){ + BinanceDexWSApiImpl(String hrp, String valHrp, BinanceDexClientEndpoint endpoint){ this.endpoint = endpoint; - this.transactionConverter = new TransactionConverter(hrp); + this.transactionConverter = new TransactionConverter(hrp, valHrp); } diff --git a/src/main/proto/dex.proto b/src/main/proto/dex.proto index df52727..0cddd20 100644 --- a/src/main/proto/dex.proto +++ b/src/main/proto/dex.proto @@ -346,4 +346,17 @@ message RefundHashTimerLockMsg { // bytes from = 1; bytes swap_id = 2; +} + +message Status { + int32 text = 1; + string finalClaim = 2; +} + +message Prophecy { + string id = 1; + Status status = 2; + + map claimValidators = 3; + map validatorClaims = 4; } \ No newline at end of file diff --git a/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java b/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java index e58339b..1c5b060 100644 --- a/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java +++ b/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java @@ -1,7 +1,24 @@ package com.binance.dex.api.client.encoding; +import com.binance.dex.api.client.BinanceDexEnvironment; +import com.binance.dex.api.client.TransactionConverter; +import com.binance.dex.api.client.Wallet; +import com.binance.dex.api.client.domain.bridge.TransferIn; +import com.binance.dex.api.client.domain.bridge.TransferOut; +import com.binance.dex.api.client.domain.broadcast.Transaction; +import com.binance.dex.api.client.domain.broadcast.TransactionOption; +import com.binance.dex.api.client.domain.oracle.ClaimMsg; +import com.binance.dex.api.client.domain.stake.Commission; +import com.binance.dex.api.client.domain.stake.Description; +import com.binance.dex.api.client.domain.stake.sidechain.*; import com.binance.dex.api.client.encoding.amino.Amino; -import com.binance.dex.api.client.encoding.message.sidechain.query.SideChainRedelegationMessage; +import com.binance.dex.api.client.encoding.message.MessageType; +import com.binance.dex.api.client.encoding.message.Token; +import com.binance.dex.api.client.encoding.message.bridge.*; +import com.binance.dex.api.client.encoding.message.common.*; +import com.binance.dex.api.client.encoding.message.sidechain.transaction.*; +import com.binance.dex.api.client.encoding.message.sidechain.value.CommissionMsgValue; +import com.binance.dex.api.client.encoding.message.sidechain.value.DescriptionValue; import com.binance.dex.api.client.encoding.message.sidechain.value.RedelegationValue; import org.bouncycastle.util.encoders.Hex; import org.junit.Assert; @@ -16,17 +33,303 @@ public class AminoTest { private final Amino amino = new Amino(); + private final Wallet wallet = new Wallet("bce1c934173e84cb4a0abf06b371f7568d3c4686da8f3ea7e1e8d230ae681920", BinanceDexEnvironment.PROD); + private final TransactionConverter transactionConverter = new TransactionConverter("bnb", "bva"); + @Test public void testDecodeRedelegation() throws IOException { - String hex = "6e0a148c7c3a06d11eacc857a7b623ca12ed963c5c53e812148c7c3a06d11eacc857a7b623ca12ed963c5c53e81a147fe359f3eaa4d2627069b32c49f854b736343c7220da522a0c08808094f50510d08dad840332080a03424e4210e8073a0b0a03424e4210d285d8cc04420a4a32"; - SideChainRedelegationMessage message = new SideChainRedelegationMessage(); - amino.decodeWithLengthPrefix(Hex.decode(hex), message); - Assert.assertNotNull(message.getDelegatorAddress()); - - hex = "2a08a554120c08c08994f50510a0b0df93011a080a03424e4210904e22090a03424e4210d099052a0a3232"; + String hex = "2a08a554120c08c08994f50510a0b0df93011a080a03424e4210904e22090a03424e4210d099052a0a3232"; RedelegationValue value = new RedelegationValue(); amino.decodeWithLengthPrefix(Hex.decode(hex), value); Assert.assertNotNull(value.getSharesDst()); } + @Test + public void testClaim() throws IOException { + ClaimMsgMessage message = new ClaimMsgMessage(); + message.setClaimType(ClaimTypes.ClaimTypeTransferIn); + message.setClaim("claim content"); + message.setSequence(1); + message.setValidatorAddress(Bech32AddressValue.fromBech32String("bva1337r5pk3r6kvs4a8kc3u5yhdjc79c5lg78343t")); + byte[] data = amino.encode(message, MessageType.Claim.getTypePrefixBytes(), false); + Transaction transaction = transactionConverter.convert(data); + System.out.println(transaction.getRealTx()); + } + + @Test + public void testTransferOut() throws IOException { + TransferOutMsgMessage message = new TransferOutMsgMessage(); + message.setAmount(new CoinValue("BNB", 1000000L)); + message.setExpireTime(System.currentTimeMillis()); + message.setFrom(Bech32AddressValue.fromBech32StringWithNewHrp("bva1337r5pk3r6kvs4a8kc3u5yhdjc79c5lg78343t", "bnb")); + message.setToAddress(EthAddressValue.from("0xd1B22dCC24C55f4d728E7aaA5c9b5a22e1512C08")); + byte[] data = amino.encode(message, MessageType.TransferOut.getTypePrefixBytes(), false); + Transaction transaction = transactionConverter.convert(data); + System.out.println(transaction.getRealTx()); + } + + @Test + public void testBind() throws IOException { + BindMsgMessage message = new BindMsgMessage(); + message.setAmount(1000000L); + message.setContractAddress(EthAddressValue.from("0xd1B22dCC24C55f4d728E7aaA5c9b5a22e1512C08")); + message.setContractDecimal(8); + message.setExpireTime(System.currentTimeMillis()); + message.setFrom(Bech32AddressValue.fromBech32StringWithNewHrp("bva1337r5pk3r6kvs4a8kc3u5yhdjc79c5lg78343t", "bnb")); + message.setSymbol("BNB"); + byte[] data = amino.encode(message, MessageType.Bind.getTypePrefixBytes(), false); + Transaction transaction = transactionConverter.convert(data); + System.out.println(transaction.getRealTx()); + } + + @Test + public void testCreateSideChainValidator() throws IOException { + CreateSideChainValidator createSideChainValidator = new CreateSideChainValidator(); + + //create and set description + Description validatorDescription = new Description(); + validatorDescription.setMoniker("custom-moniker"); + validatorDescription.setIdentity("ide"); + validatorDescription.setWebsite("https://www.website.com"); + validatorDescription.setDetails("This is a side-chain validator"); + + createSideChainValidator.setDescription(validatorDescription); + + //create and set commission + Commission commission = new Commission(); + commission.setRate(5L); + commission.setMaxRate(100L); + commission.setMaxChangeRate(5L); + + createSideChainValidator.setCommission(commission); + + //set delegator address, here use self address + createSideChainValidator.setDelegatorAddr(wallet.getAddress()); + + createSideChainValidator.setValidatorAddr(wallet.getAddress()); + + //set delegation token, here use 1000000 BNB + Token delegationToken = new Token(); + delegationToken.setDenom("BNB"); + delegationToken.setAmount(10000000000L); + createSideChainValidator.setDelegation(delegationToken); + + //set side-chain id + createSideChainValidator.setSideChainId("bsc"); + + //set side-chain validator cons address + createSideChainValidator.setSideConsAddr("0xd1B22dCC24C55f4d728E7aaA5c9b5a22e1512C08"); + + //set side-chain validator fee address + createSideChainValidator.setSideFeeAddr("0x9fB29AAc15b9A4B7F17c3385939b007540f4d791"); + + byte[] msg = amino.encode(convert(createSideChainValidator), MessageType.CreateSideChainValidator.getTypePrefixBytes(), false); + + Transaction tx = transactionConverter.convert(msg); + System.out.println(tx.getRealTx()); + } + + @Test + public void testDecodeEditSideChainValidator() throws IOException { + EditSideChainValidator editSideChainValidator = new EditSideChainValidator(); + + //set new description if needed + Description description = new Description(); + description.setMoniker("new Moniker"); + editSideChainValidator.setDescription(description); + + editSideChainValidator.setValidatorAddress(wallet.getAddress()); + + //set new rate if needed + editSideChainValidator.setCommissionRate(1L); + + //set new fee address if needed + editSideChainValidator.setSideFeeAddr("0xd1B22dCC24C55f4d728E7aaA5c9b5a22e1512C08"); + + editSideChainValidator.setSideChainId("bsc"); + + EditSideChainValidatorMessage message = new EditSideChainValidatorMessage(); + byte[] msg = amino.encode(convert(editSideChainValidator), MessageType.EditSideChainValidator.getTypePrefixBytes(), false); + + Transaction tx = transactionConverter.convert(msg); + System.out.println(tx.getRealTx()); + } + + @Test + public void testDecodeSideChainDelegate() throws IOException { + SideChainDelegate sideChainDelegate = new SideChainDelegate(); + + //set delegate token + Token delegation = new Token("BNB", 100000000L); + sideChainDelegate.setDelegation(delegation); + + //set delegator address, here is self + sideChainDelegate.setDelegatorAddress(wallet.getAddress()); + + //set validator address + sideChainDelegate.setValidatorAddress("bva1337r5pk3r6kvs4a8kc3u5yhdjc79c5lg78343t"); + + //set side-chain id + sideChainDelegate.setSideChainId("bsc"); + + byte[] msg = amino.encode(convert(sideChainDelegate), MessageType.SideChainDelegate.getTypePrefixBytes(), false); + + Transaction tx = transactionConverter.convert(msg); + System.out.println(tx.getRealTx()); + } + + @Test + public void testDecodeSideChainRedelegate() throws IOException { + SideChainRedelegate redelegate = new SideChainRedelegate(); + + //set redelegate amount + redelegate.setAmount(new Token("bnb".toUpperCase(), 100000000L)); + + //set delegator address + redelegate.setDelegatorAddress(wallet.getAddress()); + + //set source validator address + redelegate.setSrcValidatorAddress("bva1337r5pk3r6kvs4a8kc3u5yhdjc79c5lg78343t"); + + //set destination validator address + redelegate.setDstValidatorAddress("bva10l34nul25nfxyurfkvkyn7z5kumrg0rjun409e"); + + //set side-chain id + redelegate.setSideChainId("bsc"); + + byte[] msg = amino.encode(convert(redelegate), MessageType.SideChainRedelegate.getTypePrefixBytes(), false); + + Transaction tx = transactionConverter.convert(msg); + System.out.println(tx.getRealTx()); + } + + @Test + public void testDecodeSideChainUnBond() throws IOException { + SideChainUnBond sideChainUndelegate = new SideChainUnBond(); + + //set unbond amount + sideChainUndelegate.setAmount(new Token("BNB", 5000L)); + + //set delegator address + sideChainUndelegate.setDelegatorAddress(wallet.getAddress()); + + //set validator address + sideChainUndelegate.setValidatorAddress("bva1337r5pk3r6kvs4a8kc3u5yhdjc79c5lg78343t"); + + //set side-chain id + sideChainUndelegate.setSideChainId("bsc"); + + byte[] msg = amino.encode(convert(sideChainUndelegate), MessageType.SideChainUndelegate.getTypePrefixBytes(), false); + + Transaction tx = transactionConverter.convert(msg); + System.out.println(tx.getRealTx()); + } + + EditSideChainValidatorMessage convert(EditSideChainValidator editSideChainValidator){ + EditSideChainValidatorMessage message = new EditSideChainValidatorMessage(); + + if (editSideChainValidator.getDescription() != null){ + message.setDescription(convert(editSideChainValidator.getDescription())); + } + + message.setValidatorOperatorAddress(Bech32AddressValue.fromBech32String(editSideChainValidator.getValidatorAddress())); + + message.setCommissionRate(Dec.newInstance(editSideChainValidator.getCommissionRate())); + message.setSideChainId(editSideChainValidator.getSideChainId()); + message.setSideFeeAddr(decodeHexAddress(editSideChainValidator.getSideFeeAddr())); + + return message; + } + + CreateSideChainValidatorMessage convert(CreateSideChainValidator createSideChainValidator){ + CreateSideChainValidatorMessage message = new CreateSideChainValidatorMessage(); + + if (createSideChainValidator.getDescription() != null){ + message.setDescription(convert(createSideChainValidator.getDescription())); + } + if (createSideChainValidator.getCommission() != null){ + message.setCommission(convert(createSideChainValidator.getCommission())); + } + + message.setDelegatorAddr(Bech32AddressValue.fromBech32String(createSideChainValidator.getDelegatorAddr())); + message.setValidatorOperatorAddr(Bech32AddressValue.fromBech32String(createSideChainValidator.getValidatorAddr())); + + if (createSideChainValidator.getDelegation() != null){ + message.setDelegation(convert(createSideChainValidator.getDelegation())); + } + + message.setSideChainId(createSideChainValidator.getSideChainId()); + message.setSideConsAddr(decodeHexAddress(createSideChainValidator.getSideConsAddr())); + message.setSideFeeAddr(decodeHexAddress(createSideChainValidator.getSideFeeAddr())); + return message; + } + + private DescriptionValue convert(Description description){ + DescriptionValue value = new DescriptionValue(); + value.setMoniker(description.getMoniker()); + value.setDetails(description.getDetails()); + value.setIdentity(description.getIdentity()); + value.setWebsite(description.getWebsite()); + return value; + } + + private CommissionMsgValue convert(Commission commission){ + CommissionMsgValue value = new CommissionMsgValue(); + value.setRate(Dec.newInstance(commission.getRate())); + value.setMaxRate(Dec.newInstance(commission.getMaxRate())); + value.setMaxChangeRate(Dec.newInstance(commission.getMaxChangeRate())); + return value; + } + + private CoinValueStr convert(Token token){ + CoinValueStr value = new CoinValueStr(); + value.setDenom(token.getDenom()); + value.setAmount(token.getAmount()); + return value; + } + + private SideChainDelegateMessage convert(SideChainDelegate sideChainDelegate){ + SideChainDelegateMessage message = new SideChainDelegateMessage(); + message.setDelegatorAddress(Bech32AddressValue.fromBech32String(sideChainDelegate.getDelegatorAddress())); + message.setValidatorAddress(Bech32AddressValue.fromBech32String(sideChainDelegate.getValidatorAddress())); + + if (sideChainDelegate.getDelegation() != null) { + message.setDelegation(convert(sideChainDelegate.getDelegation())); + } + + message.setSideChainId(sideChainDelegate.getSideChainId()); + return message; + } + + private SideChainRedelegateMessage convert(SideChainRedelegate redelegate){ + SideChainRedelegateMessage message = new SideChainRedelegateMessage(); + message.setDelegatorAddress(Bech32AddressValue.fromBech32String(redelegate.getDelegatorAddress())); + message.setSrcValidatorAddress(Bech32AddressValue.fromBech32String(redelegate.getSrcValidatorAddress())); + message.setDstValidatorAddress(Bech32AddressValue.fromBech32String(redelegate.getDstValidatorAddress())); + if (redelegate.getAmount() != null) { + message.setAmount(convert(redelegate.getAmount())); + } + message.setSideChainId(redelegate.getSideChainId()); + return message; + } + + private SideChainUndelegateMessage convert(SideChainUnBond unBond){ + SideChainUndelegateMessage message = new SideChainUndelegateMessage(); + message.setDelegatorAddress(Bech32AddressValue.fromBech32String(unBond.getDelegatorAddress())); + message.setValidatorAddress(Bech32AddressValue.fromBech32String(unBond.getValidatorAddress())); + if (unBond.getAmount() != null) { + message.setAmount(convert(unBond.getAmount())); + } + message.setSideChainId(unBond.getSideChainId()); + return message; + } + + private byte[] decodeHexAddress(String address){ + String addr = address; + if (addr.startsWith("0x")){ + addr = address.substring(2); + } + return Hex.decode(addr); + } + } diff --git a/src/test/java/com/binance/dex/api/client/examples/BridgeNodeExample.java b/src/test/java/com/binance/dex/api/client/examples/BridgeNodeExample.java new file mode 100644 index 0000000..b2967d2 --- /dev/null +++ b/src/test/java/com/binance/dex/api/client/examples/BridgeNodeExample.java @@ -0,0 +1,190 @@ +package com.binance.dex.api.client.examples; + +import com.binance.dex.api.client.BinanceDexApiClientFactory; +import com.binance.dex.api.client.BinanceDexApiNodeClient; +import com.binance.dex.api.client.BinanceDexEnvironment; +import com.binance.dex.api.client.Wallet; +import com.binance.dex.api.client.domain.TransactionMetadata; +import com.binance.dex.api.client.domain.bridge.TransferIn; +import com.binance.dex.api.client.domain.broadcast.TransactionOption; +import com.binance.dex.api.client.domain.oracle.Prophecy; +import com.binance.dex.api.client.encoding.message.Token; +import com.binance.dex.api.client.encoding.message.bridge.BindStatus; +import com.binance.dex.api.client.encoding.message.bridge.ClaimTypes; +import com.binance.dex.api.client.encoding.message.bridge.RefundReason; +import org.junit.Before; +import org.junit.Test; + +import java.io.IOException; +import java.security.NoSuchAlgorithmException; +import java.util.ArrayList; +import java.util.List; + +/** + * @author Fitz.Lu + **/ +public class BridgeNodeExample { + + private BinanceDexApiNodeClient nodeClient = null; + private final Wallet wallet = new Wallet("66d08fc209b31090ea21a8cf9a6e2680b008e2b905b2358ae31e0f42b140de99", BinanceDexEnvironment.TEST_NET); + + @Before + public void setup() { + nodeClient = BinanceDexApiClientFactory.newInstance().newNodeRpcClient(BinanceDexEnvironment.TEST_NET.getNodeUrl(),BinanceDexEnvironment.TEST_NET.getHrp(), BinanceDexEnvironment.TEST_NET.getValHrp()); + } + + @Test + public void transferIn(){ + TransferIn transferIn = new TransferIn(); + transferIn.setContractAddress("0xd1B22dCC24C55f4d728E7aaA5c9b5a22e1512C08"); + + List refundAddresses = new ArrayList<>(); + refundAddresses.add("0x9fB29AAc15b9A4B7F17c3385939b007540f4d791"); + transferIn.setRefundAddresses(refundAddresses); + + List receiverAddresses = new ArrayList<>(); + receiverAddresses.add(wallet.getAddress()); + transferIn.setReceiverAddresses(receiverAddresses); + + List amounts = new ArrayList<>(); + amounts.add(100000L); + transferIn.setAmounts(amounts); + + transferIn.setSymbol("BNB"); + + transferIn.setRelayFee(new Token("BNB", 10L)); + + transferIn.setExpireTime((System.currentTimeMillis() + 1000 * 60 * 60 * 24 * 3) / 1000); + + TransactionOption options = new TransactionOption("", 0, null); + + long sequence = nodeClient.getCurrentSequence(ClaimTypes.ClaimTypeTransferIn); + + try { + List results = nodeClient.transferIn(sequence, transferIn, wallet, options, true); + if (results != null){ + for (TransactionMetadata result : results) { + System.out.println(result.toString()); + } + } + } catch (IOException | NoSuchAlgorithmException e) { + e.printStackTrace(); + } + } + + @Test + public void transferOut(){ + String toAddress = "0x9fB29AAc15b9A4B7F17c3385939b007540f4d791"; + Token token = new Token("BNB", 100000L); + long expireTime = System.currentTimeMillis() + 1000 * 60 * 60 * 24 * 3; + + TransactionOption options = new TransactionOption("", 0, null); + + try { + List results = nodeClient.transferOut(toAddress, token, expireTime / 1000, wallet, options, true); + if (results != null){ + for (TransactionMetadata result : results) { + System.out.println(result.toString()); + } + } + } catch (IOException | NoSuchAlgorithmException e) { + e.printStackTrace(); + } + } + + @Test + public void bind(){ + String symbol = "BNB"; + long amount = 1000000L; + String contractAddress = "0xd1B22dCC24C55f4d728E7aaA5c9b5a22e1512C08"; + int contractDecimal = 2; + long expireTime = System.currentTimeMillis() + 1000 * 60 * 60 * 24 * 3; + + TransactionOption options = new TransactionOption("", 0, null); + + try { + List results = nodeClient.bind(symbol, amount, contractAddress, contractDecimal, expireTime / 1000, wallet, options, true); + if (results != null){ + for (TransactionMetadata result : results) { + System.out.println(result.toString()); + } + } + } catch (IOException | NoSuchAlgorithmException e) { + e.printStackTrace(); + } + } + + @Test + public void updateTransferOut(){ + long sequence = nodeClient.getCurrentSequence(ClaimTypes.ClaimTypeUpdateTransferOut); + String refundAddress = wallet.getAddress(); + Token amount = new Token("BNB", 100000L); + int refundReason = RefundReason.timeout; + + TransactionOption options = new TransactionOption("", 0, null); + + try { + List results = nodeClient.updateTransferOut(sequence, refundAddress, amount, refundReason, wallet, options, true); + if (results != null){ + for (TransactionMetadata result : results) { + System.out.println(result.toString()); + } + } + } catch (IOException | NoSuchAlgorithmException e) { + e.printStackTrace(); + } + } + + @Test + public void updateBind(){ + long sequence = nodeClient.getCurrentSequence(ClaimTypes.ClaimTypeUpdateBind); + String symbol = "BNB"; + String contractAddress = "0xd1B22dCC24C55f4d728E7aaA5c9b5a22e1512C08"; + int status = BindStatus.bindStatusSuccess; + + TransactionOption options = new TransactionOption("", 0, null); + + try { + List results = nodeClient.updateBind(sequence, symbol, contractAddress, status, wallet, options, true); + if (results != null){ + for (TransactionMetadata result : results) { + System.out.println(result.toString()); + } + } + } catch (IOException | NoSuchAlgorithmException e) { + e.printStackTrace(); + } + } + + @Test + public void claim(){ + TransactionOption options = new TransactionOption("", 0, null); + try { + List results = nodeClient.claim(ClaimTypes.ClaimTypeUpdateBind, "claim message", 1, wallet, options, true); + if (results != null){ + for (TransactionMetadata result : results) { + System.out.println(result.toString()); + } + } + } catch (IOException | NoSuchAlgorithmException e) { + e.printStackTrace(); + } + } + + @Test + public void getProphecy(){ + try { + Prophecy prophecy = nodeClient.getProphecy(ClaimTypes.ClaimTypeTransferIn, 1); + System.out.println(prophecy.toString()); + } catch (NullPointerException | IOException e) { + e.printStackTrace(); + } + } + + @Test + public void getCurrentSequence(){ + long sequence = nodeClient.getCurrentSequence(ClaimTypes.ClaimTypeTransferIn); + System.out.println(sequence); + } + +} diff --git a/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java b/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java index 2c20c8a..920ec61 100644 --- a/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java +++ b/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java @@ -28,7 +28,7 @@ public class NodeClientExample { @Before public void setup() { - binanceDexNodeApi = BinanceDexApiClientFactory.newInstance().newNodeRpcClient(BinanceDexEnvironment.TEST_NET.getNodeUrl(),BinanceDexEnvironment.TEST_NET.getHrp()); + binanceDexNodeApi = BinanceDexApiClientFactory.newInstance().newNodeRpcClient(BinanceDexEnvironment.TEST_NET.getNodeUrl(),BinanceDexEnvironment.TEST_NET.getHrp(), BinanceDexEnvironment.TEST_NET.getValHrp()); } @Test diff --git a/src/test/java/com/binance/dex/api/client/examples/SideChainStakingNodeExample.java b/src/test/java/com/binance/dex/api/client/examples/SideChainStakingNodeExample.java index 061dc4f..a56ec2c 100644 --- a/src/test/java/com/binance/dex/api/client/examples/SideChainStakingNodeExample.java +++ b/src/test/java/com/binance/dex/api/client/examples/SideChainStakingNodeExample.java @@ -4,10 +4,12 @@ import com.binance.dex.api.client.BinanceDexApiNodeClient; import com.binance.dex.api.client.BinanceDexEnvironment; import com.binance.dex.api.client.Wallet; -import com.binance.dex.api.client.domain.sidechain.*; import com.binance.dex.api.client.domain.TransactionMetadata; import com.binance.dex.api.client.domain.broadcast.*; -import com.binance.dex.api.client.encoding.Crypto; +import com.binance.dex.api.client.domain.stake.Commission; +import com.binance.dex.api.client.domain.stake.Description; +import com.binance.dex.api.client.domain.stake.Pool; +import com.binance.dex.api.client.domain.stake.sidechain.*; import com.binance.dex.api.client.encoding.message.*; import org.junit.Assert; import org.junit.Before; @@ -23,11 +25,20 @@ public class SideChainStakingNodeExample { private BinanceDexApiNodeClient nodeClient = null; - private final Wallet wallet = new Wallet("66d08fc209b31090ea21a8cf9a6e2680b008e2b905b2358ae31e0f42b140de99", BinanceDexEnvironment.TEST_NET); + + private String jackPrivKey = "bce1c934173e84cb4a0abf06b371f7568d3c4686da8f3ea7e1e8d230ae681920"; + private String rosePrivKey = "50111155e4d9adca98c3f9318e896aedeac7fbec8c9f416af076ff042c56b4c5"; + private String markPrivKey = "68931b8fe68ebec5b8fe81420b8de3d47f4ad1dd01619c7e0c93ce9c3a0e3d22"; + + private String jackValidator = "bva1lrzg56jhtkqu7fmca3394vdx00r7apx4gjdzy2"; + private String roseValidator = "bva1rxnydtfjccaz2tck7wrentntdylrnnqzmspush"; + + private final Wallet wallet = new Wallet(markPrivKey, BinanceDexEnvironment.PROD); @Before public void setup() { - nodeClient = BinanceDexApiClientFactory.newInstance().newNodeRpcClient(BinanceDexEnvironment.TEST_NET.getNodeUrl(),BinanceDexEnvironment.TEST_NET.getHrp()); + nodeClient = BinanceDexApiClientFactory.newInstance().newNodeRpcClient(BinanceDexEnvironment.TEST_NET.getNodeUrl() + ,BinanceDexEnvironment.TEST_NET.getHrp(), BinanceDexEnvironment.TEST_NET.getValHrp()); } @Test @@ -36,18 +47,18 @@ public void testCreateSideChainValidator(){ //create and set description Description validatorDescription = new Description(); - validatorDescription.setMoniker("custom-moniker"); - validatorDescription.setIdentity("ide"); - validatorDescription.setWebsite("https://www.website.com"); - validatorDescription.setDetails("This is a side-chain validator"); + validatorDescription.setMoniker("rose-moniker"); + validatorDescription.setIdentity("rose id"); + validatorDescription.setWebsite("https://www.rose.com"); + validatorDescription.setDetails("This is rose validator"); createSideChainValidator.setDescription(validatorDescription); //create and set commission Commission commission = new Commission(); commission.setRate(5L); - commission.setMaxRate(100L); - commission.setMaxChangeRate(5L); + commission.setMaxRate(1000L); + commission.setMaxChangeRate(10L); createSideChainValidator.setCommission(commission); @@ -57,17 +68,17 @@ public void testCreateSideChainValidator(){ //set delegation token, here use 1000000 BNB Token delegationToken = new Token(); delegationToken.setDenom("BNB"); - delegationToken.setAmount(10000000000L); + delegationToken.setAmount(1000000000000L); createSideChainValidator.setDelegation(delegationToken); //set side-chain id createSideChainValidator.setSideChainId("bsc"); //set side-chain validator cons address - createSideChainValidator.setSideConsAddr("0xd1B22dCC24C55f4d728E7aaA5c9b5a22e1512C08"); + createSideChainValidator.setSideConsAddr("0x9fB29AAc15b9A4B7F17c3385939b007540f4d791"); //set side-chain validator fee address - createSideChainValidator.setSideFeeAddr("0x9fB29AAc15b9A4B7F17c3385939b007540f4d791"); + createSideChainValidator.setSideFeeAddr("0xd1B22dCC24C55f4d728E7aaA5c9b5a22e1512C08"); TransactionOption options = new TransactionOption("", 0, null); @@ -93,9 +104,6 @@ public void testEditSideChainValidator(){ //set new rate if needed editSideChainValidator.setCommissionRate(1L); - //set new cons address needed - editSideChainValidator.setSideConsAddr("0x9fB29AAc15b9A4B7F17c3385939b007540f4d791"); - //set new fee address if needed editSideChainValidator.setSideFeeAddr("0xd1B22dCC24C55f4d728E7aaA5c9b5a22e1512C08"); @@ -116,14 +124,14 @@ public void testSideChainDelegate(){ SideChainDelegate sideChainDelegate = new SideChainDelegate(); //set delegate token - Token delegation = new Token("BNB", 100000000L); + Token delegation = new Token("BNB", 123456700L); sideChainDelegate.setDelegation(delegation); //set delegator address, here is self sideChainDelegate.setDelegatorAddress(wallet.getAddress()); //set validator address - sideChainDelegate.setValidatorAddress("bva1337r5pk3r6kvs4a8kc3u5yhdjc79c5lg78343t"); + sideChainDelegate.setValidatorAddress(roseValidator); //set side-chain id sideChainDelegate.setSideChainId("bsc"); @@ -149,10 +157,10 @@ public void testSideChainRedelegate(){ redelegate.setDelegatorAddress(wallet.getAddress()); //set source validator address - redelegate.setSrcValidatorAddress("bva1337r5pk3r6kvs4a8kc3u5yhdjc79c5lg78343t"); + redelegate.setSrcValidatorAddress(jackValidator); //set destination validator address - redelegate.setDstValidatorAddress("bva10l34nul25nfxyurfkvkyn7z5kumrg0rjun409e"); + redelegate.setDstValidatorAddress(roseValidator); //set side-chain id redelegate.setSideChainId("bsc"); @@ -170,13 +178,13 @@ public void testSideChainUnbond(){ SideChainUnBond sideChainUndelegate = new SideChainUnBond(); //set unbond amount - sideChainUndelegate.setAmount(new Token("BNB", 5000L)); + sideChainUndelegate.setAmount(new Token("BNB", 1000L)); //set delegator address sideChainUndelegate.setDelegatorAddress(wallet.getAddress()); //set validator address - sideChainUndelegate.setValidatorAddress("bva1337r5pk3r6kvs4a8kc3u5yhdjc79c5lg78343t"); + sideChainUndelegate.setValidatorAddress(jackValidator); //set side-chain id sideChainUndelegate.setSideChainId("bsc"); @@ -191,7 +199,7 @@ public void testSideChainUnbond(){ @Test public void testGetSideChainValidator() throws IOException { - SideChainValidator validator = nodeClient.getSideChainValidator("bsc", decodeAddress("bva1337r5pk3r6kvs4a8kc3u5yhdjc79c5lg78343t")); + SideChainValidator validator = nodeClient.getSideChainValidator("bsc", jackValidator); Assert.assertNotNull(validator); consolePrintln(validator); } @@ -206,14 +214,15 @@ public void testGetSideChainTopValidators() throws IOException { @Test public void testGetSideChainDelegation() throws IOException { - SideChainDelegation delegation = nodeClient.getSideChainDelegation("bsc", wallet.getAddressBytes(), decodeAddress("bva1337r5pk3r6kvs4a8kc3u5yhdjc79c5lg78343t")); - Assert.assertNotNull(delegation); - consolePrintln(delegation); + SideChainDelegation delegation = nodeClient.getSideChainDelegation("bsc", wallet.getAddress(), roseValidator); + if (delegation != null) { + consolePrintln(delegation); + } } @Test public void testGetSideChainDelegations() throws IOException { - List delegations = nodeClient.getSideChainDelegations("bsc", wallet.getAddressBytes()); + List delegations = nodeClient.getSideChainDelegations("bsc", wallet.getAddress()); for (SideChainDelegation delegation : delegations) { consolePrintln(delegation); } @@ -221,10 +230,7 @@ public void testGetSideChainDelegations() throws IOException { @Test public void getSideChainRedelegation() throws IOException { - byte[] srcValidatorAddress = decodeAddress("bva1337r5pk3r6kvs4a8kc3u5yhdjc79c5lg78343t"); - byte[] dstValidatorAddress = decodeAddress("bva10l34nul25nfxyurfkvkyn7z5kumrg0rjun409e"); - - SideChainRedelegation redelegation = nodeClient.getSideChainRedelegation("bsc", wallet.getAddressBytes(), srcValidatorAddress, dstValidatorAddress); + SideChainRedelegation redelegation = nodeClient.getSideChainRedelegation("bsc", wallet.getAddress(), jackValidator, roseValidator); if (redelegation != null) { consolePrintln(redelegation); } @@ -232,7 +238,7 @@ public void getSideChainRedelegation() throws IOException { @Test public void getSideChainRedelegations() throws IOException { - List redelegations = nodeClient.getSideChainRedelegations("bsc", wallet.getAddressBytes()); + List redelegations = nodeClient.getSideChainRedelegations("bsc", wallet.getAddress()); for (SideChainRedelegation redelegation : redelegations) { consolePrintln(redelegation); } @@ -240,20 +246,46 @@ public void getSideChainRedelegations() throws IOException { @Test public void getSideChainUnBondingDelegation() throws IOException { - SideChainUnBondingDelegation unBondingDelegation = nodeClient.getSideChainUnBondingDelegation("bsc", wallet.getAddressBytes(), decodeAddress("bva1337r5pk3r6kvs4a8kc3u5yhdjc79c5lg78343t")); - consolePrintln(unBondingDelegation); + UnBondingDelegation unBondingDelegation = nodeClient.getSideChainUnBondingDelegation("bsc", wallet.getAddress(), jackValidator); + if (unBondingDelegation != null) { + consolePrintln(unBondingDelegation); + } } @Test public void getSideChainUnBondingDelegations() throws IOException { - List unBondingDelegations = nodeClient.getSideChainUnBondingDelegations("bsc", wallet.getAddressBytes()); - for (SideChainUnBondingDelegation unBondingDelegation : unBondingDelegations) { + List unBondingDelegations = nodeClient.getSideChainUnBondingDelegations("bsc", wallet.getAddress()); + for (UnBondingDelegation unBondingDelegation : unBondingDelegations) { + consolePrintln(unBondingDelegation); + } + } + + @Test + public void testGetSideChainUnBondingDelegationsByValidator() throws IOException { + List unBondingDelegations = nodeClient.getSideChainUnBondingDelegationsByValidator("bsc", jackValidator); + for (UnBondingDelegation unBondingDelegation : unBondingDelegations) { consolePrintln(unBondingDelegation); } } - private byte[] decodeAddress(String address){ - return Crypto.decodeAddress(address); + @Test + public void testGetSideChainRedelegationsByValidator() throws IOException { + List redelegations = nodeClient.getSideChainRedelegationsByValidator("bsc", jackValidator); + for (SideChainRedelegation redelegation : redelegations) { + consolePrintln(redelegation); + } + } + + @Test + public void testGetSideChainPool() throws IOException { + Pool pool = nodeClient.getSideChainPool("bsc"); + consolePrintln(pool); + } + + @Test + public void testGetSideChainValidatorsCount() throws IOException { + long count = nodeClient.getAllSideChainValidatorsCount("bsc", false); + consolePrintln(count); } /** From fe83dad54ae911aafdc8450f10679e2675a57774 Mon Sep 17 00:00:00 2001 From: "fletcher.fan" Date: Wed, 6 May 2020 16:02:08 +0800 Subject: [PATCH 04/52] add slash relevant tx parse --- .../dex/api/client/TransactionConverter.java | 158 ++++++++++++------ .../api/client/domain/broadcast/TxType.java | 4 +- .../api/client/domain/slash/BscHeader.java | 57 +++++++ .../domain/slash/BscSubmitEvidence.java | 13 ++ .../client/domain/slash/SideChainUnJail.java | 14 ++ .../client/encoding/message/MessageType.java | 5 +- .../BytesToPrefixedHexStringSerializer.java | 18 ++ .../serializer/LongToHexStringSerializer.java | 17 ++ src/main/proto/dex.proto | 30 ++++ 9 files changed, 265 insertions(+), 51 deletions(-) create mode 100644 src/main/java/com/binance/dex/api/client/domain/slash/BscHeader.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/slash/BscSubmitEvidence.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/slash/SideChainUnJail.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/serializer/BytesToPrefixedHexStringSerializer.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/serializer/LongToHexStringSerializer.java diff --git a/src/main/java/com/binance/dex/api/client/TransactionConverter.java b/src/main/java/com/binance/dex/api/client/TransactionConverter.java index b991a3a..0e166a9 100644 --- a/src/main/java/com/binance/dex/api/client/TransactionConverter.java +++ b/src/main/java/com/binance/dex/api/client/TransactionConverter.java @@ -20,6 +20,8 @@ import com.binance.dex.api.client.domain.broadcast.Vote; import com.binance.dex.api.client.domain.jsonrpc.TxResult; import com.binance.dex.api.client.domain.oracle.ClaimMsg; +import com.binance.dex.api.client.domain.slash.BscSubmitEvidence; +import com.binance.dex.api.client.domain.slash.SideChainUnJail; import com.binance.dex.api.client.domain.stake.Commission; import com.binance.dex.api.client.domain.stake.Description; import com.binance.dex.api.client.domain.stake.sidechain.*; @@ -54,7 +56,7 @@ public class TransactionConverter { private final Amino amino = new Amino(); - public TransactionConverter(String hrp, String valHrp){ + public TransactionConverter(String hrp, String valHrp) { this.hrp = hrp; this.valHrp = valHrp; } @@ -82,7 +84,7 @@ public List convert(com.binance.dex.api.client.domain.jsonrpc.Block transaction.setResultData(Optional.ofNullable(txMessage.getTx_result()).map(TxResult::getData).orElse(null)); transaction.setSource(stdTx.getSource()); transaction.setSequence(stdSignature.getSequence()); - fillTagsAndEvents(txMessage.getTx_result(),transaction); + fillTagsAndEvents(txMessage.getTx_result(), transaction); return transaction; }).filter(Objects::nonNull).collect(Collectors.toList()); } catch (InvalidProtocolBufferException e) { @@ -90,32 +92,32 @@ public List convert(com.binance.dex.api.client.domain.jsonrpc.Block } } - public void fillTagsAndEvents(TxResult txResult,Transaction transaction){ + public void fillTagsAndEvents(TxResult txResult, Transaction transaction) { boolean hasTags = txResult.getTags() != null && txResult.getTags().size() > 0; boolean hasEvents = txResult.getEvents() != null && txResult.getEvents().size() > 0 && txResult.getEvents().get(0).getAttributes() != null && txResult.getEvents().get(0).getAttributes().size() > 0; - if(hasTags && !hasEvents){ + if (hasTags && !hasEvents) { transaction.setTags(txResult.getTags()); List attributes = txResult.getTags().stream().map(this::convertOf).collect(Collectors.toList()); TxResult.Event event = new TxResult.Event(); event.setAttributes(attributes); transaction.setEvents(Collections.singletonList(event)); - }else if(hasEvents && !hasTags){ + } else if (hasEvents && !hasTags) { transaction.setEvents(txResult.getEvents()); List tags = txResult.getEvents().get(0).getAttributes().stream().map(this::convertOf).collect(Collectors.toList()); transaction.setTags(tags); } } - private TxResult.Attribute convertOf(TxResult.Tag tag){ + private TxResult.Attribute convertOf(TxResult.Tag tag) { TxResult.Attribute attribute = new TxResult.Attribute(); attribute.setKey(tag.getKey()); attribute.setValue(tag.getValue()); return attribute; } - private TxResult.Tag convertOf(TxResult.Attribute attribute){ + private TxResult.Tag convertOf(TxResult.Attribute attribute) { TxResult.Tag tag = new TxResult.Tag(); tag.setKey(attribute.getKey()); tag.setValue(attribute.getValue()); @@ -199,6 +201,10 @@ public Transaction convert(byte[] bytes) { return convertTransferOutMsg(bytes); case Bind: return convertBindMsg(bytes); + case BscSubmitEvidence: + return convertBscSubmitEvidence(bytes); + case SideChainUnJail: + return convertSideChainUnJail(bytes); } return null; } catch (Exception e) { @@ -206,13 +212,68 @@ public Transaction convert(byte[] bytes) { } } + private Transaction convertSideChainUnJail(byte[] value) throws IOException { + byte[] raw = ByteUtil.cut(value, 4); + SideChainUnJailMsg message = SideChainUnJailMsg.parseFrom(raw); + + SideChainUnJail unJail = new SideChainUnJail(); + unJail.setSideChainId(message.getSideChainId()); + unJail.setValidatorAddr(Crypto.encodeAddress(valHrp, message.getAddress().toByteArray())); + + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.SIDECHAIN_UNJAIL); + transaction.setRealTx(unJail); + return transaction; + } + + private Transaction convertBscSubmitEvidence(byte[] value) throws IOException { + byte[] raw = ByteUtil.cut(value, 4); + SubmitEvidenceMsg message = SubmitEvidenceMsg.parseFrom(raw); + + BscSubmitEvidence bscSubmitEvidence = new BscSubmitEvidence(); + if (message.getSubmitter() != null && raw != null) { + bscSubmitEvidence.setSubmitter(Crypto.encodeAddress(hrp, message.getSubmitter().toByteArray())); + } + + List headers = message.getHeadersList(); + if (headers != null && headers.size() > 0) { + com.binance.dex.api.client.domain.slash.BscHeader[] bscHeaders = new com.binance.dex.api.client.domain.slash.BscHeader[headers.size()]; + com.binance.dex.api.client.domain.slash.BscHeader bscHeader; + for (int i = 0; i < headers.size(); i++) { + bscHeader = new com.binance.dex.api.client.domain.slash.BscHeader(); + bscHeader.setParentHash(headers.get(i).getParentHash().toByteArray()); + bscHeader.setSha3Uncles(headers.get(i).getSha3Uncles().toByteArray()); + bscHeader.setMiner(headers.get(i).getMiner().toByteArray()); + bscHeader.setStateRoot(headers.get(i).getStateRoot().toByteArray()); + bscHeader.setTransactionsRoot(headers.get(i).getTransactionsRoot().toByteArray()); + bscHeader.setReceiptsRoot(headers.get(i).getReceiptsRoot().toByteArray()); + bscHeader.setLogsBloom(headers.get(i).getLogsBloom().toByteArray()); + bscHeader.setDifficulty(headers.get(i).getDifficulty()); + bscHeader.setNumber(headers.get(i).getNumber()); + bscHeader.setGasLimit(headers.get(i).getGasLimit()); + bscHeader.setGasUsed(headers.get(i).getGasUsed()); + bscHeader.setTimestamp(headers.get(i).getTimestamp()); + bscHeader.setExtra(headers.get(i).getExtraData().toByteArray()); + bscHeader.setMixHash(headers.get(i).getMixHash().toByteArray()); + bscHeader.setNonce(headers.get(i).getNonce().toByteArray()); + bscHeaders[i] = bscHeader; + } + bscSubmitEvidence.setHeaders(bscHeaders); + } + + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.BSC_SUBMIT_EVIDENCE); + transaction.setRealTx(bscSubmitEvidence); + return transaction; + } + private Transaction convertBindMsg(byte[] value) throws IOException { byte[] raw = ByteUtil.cut(value, 4); BindMsgMessage message = new BindMsgMessage(); amino.decodeBare(raw, message); Bind bind = new Bind(); - if (message.getFrom() != null && message.getFrom().getRaw() != null){ + if (message.getFrom() != null && message.getFrom().getRaw() != null) { bind.setFrom(Crypto.encodeAddress(hrp, message.getFrom().getRaw())); } bind.setSymbol(message.getSymbol()); @@ -236,15 +297,15 @@ private Transaction convertTransferOutMsg(byte[] value) throws IOException { amino.decodeBare(raw, message); TransferOut transferOut = new TransferOut(); - if (message.getFrom() != null && message.getFrom().getRaw() != null){ + if (message.getFrom() != null && message.getFrom().getRaw() != null) { transferOut.setFrom(Crypto.encodeAddress(hrp, message.getFrom().getRaw())); } - if (message.getToAddress() != null){ + if (message.getToAddress() != null) { transferOut.setToAddress(message.getToAddress().getAddress()); } Token token = new Token(); - if (message.getAmount() != null){ + if (message.getAmount() != null) { token.setAmount(message.getAmount().getAmount()); token.setDenom(message.getAmount().getDenom()); } @@ -285,16 +346,16 @@ private Transaction convertSideChainUnBond(byte[] value) throws IOException { SideChainUnBond unBond = new SideChainUnBond(); - if (message.getDelegatorAddress() != null && message.getDelegatorAddress().getRaw() != null){ + if (message.getDelegatorAddress() != null && message.getDelegatorAddress().getRaw() != null) { unBond.setDelegatorAddress(Crypto.encodeAddress(hrp, message.getDelegatorAddress().getRaw())); } - if (message.getValidatorAddress() != null && message.getValidatorAddress().getRaw() != null){ + if (message.getValidatorAddress() != null && message.getValidatorAddress().getRaw() != null) { unBond.setValidatorAddress(Crypto.encodeAddress(valHrp, message.getValidatorAddress().getRaw())); } Token amount = new Token(); - if (message.getAmount() != null){ + if (message.getAmount() != null) { amount.setAmount(message.getAmount().getAmount()); amount.setDenom(message.getAmount().getDenom()); } @@ -315,20 +376,20 @@ private Transaction convertSideChainRedelegate(byte[] value) throws IOException amino.decodeBare(raw, message); SideChainRedelegate redelegate = new SideChainRedelegate(); - if (message.getDelegatorAddress() != null && message.getDelegatorAddress().getRaw() != null){ + if (message.getDelegatorAddress() != null && message.getDelegatorAddress().getRaw() != null) { redelegate.setDelegatorAddress(Crypto.encodeAddress(hrp, message.getDelegatorAddress().getRaw())); } - if (message.getSrcValidatorAddress() != null && message.getSrcValidatorAddress().getRaw() != null){ + if (message.getSrcValidatorAddress() != null && message.getSrcValidatorAddress().getRaw() != null) { redelegate.setSrcValidatorAddress(Crypto.encodeAddress(valHrp, message.getSrcValidatorAddress().getRaw())); } - if (message.getDstValidatorAddress() != null && message.getDstValidatorAddress().getRaw() != null){ + if (message.getDstValidatorAddress() != null && message.getDstValidatorAddress().getRaw() != null) { redelegate.setDstValidatorAddress(Crypto.encodeAddress(valHrp, message.getDstValidatorAddress().getRaw())); } Token amount = new Token(); - if (message.getAmount() != null){ + if (message.getAmount() != null) { amount.setAmount(message.getAmount().getAmount()); amount.setDenom(message.getAmount().getDenom()); } @@ -349,16 +410,16 @@ private Transaction convertSideChainDelegate(byte[] value) throws IOException { amino.decodeBare(raw, message); SideChainDelegate sideChainDelegate = new SideChainDelegate(); - if (message.getDelegatorAddress() != null && message.getDelegatorAddress().getRaw() != null){ + if (message.getDelegatorAddress() != null && message.getDelegatorAddress().getRaw() != null) { sideChainDelegate.setDelegatorAddress(Crypto.encodeAddress(hrp, message.getDelegatorAddress().getRaw())); } - if (message.getValidatorAddress() != null && message.getValidatorAddress().getRaw() != null){ + if (message.getValidatorAddress() != null && message.getValidatorAddress().getRaw() != null) { sideChainDelegate.setValidatorAddress(Crypto.encodeAddress(valHrp, message.getValidatorAddress().getRaw())); } Token token = new Token(); - if (message.getDelegation() != null){ + if (message.getDelegation() != null) { token.setDenom(message.getDelegation().getDenom()); token.setAmount(message.getDelegation().getAmount()); } @@ -381,7 +442,7 @@ private Transaction convertEditSideChainValidator(byte[] value) throws IOExcepti EditSideChainValidator editSideChainValidator = new EditSideChainValidator(); Description description = new Description(); - if (message.getDescription() != null){ + if (message.getDescription() != null) { description.setMoniker(message.getDescription().getMoniker()); description.setDetails(message.getDescription().getDetails()); description.setIdentity(message.getDescription().getIdentity()); @@ -389,11 +450,11 @@ private Transaction convertEditSideChainValidator(byte[] value) throws IOExcepti } editSideChainValidator.setDescription(description); - if (message.getValidatorOperatorAddress() != null && message.getValidatorOperatorAddress().getRaw() != null){ + if (message.getValidatorOperatorAddress() != null && message.getValidatorOperatorAddress().getRaw() != null) { editSideChainValidator.setValidatorAddress(Crypto.encodeAddress(valHrp, message.getValidatorOperatorAddress().getRaw())); } - if (message.getCommissionRate() != null){ + if (message.getCommissionRate() != null) { editSideChainValidator.setCommissionRate(message.getCommissionRate().getValue()); } @@ -418,7 +479,7 @@ private Transaction convertCreateSideChainValidator(byte[] value) throws IOExcep CreateSideChainValidator createSideChainValidator = new CreateSideChainValidator(); Description description = new Description(); - if (message.getDescription() != null){ + if (message.getDescription() != null) { description.setMoniker(message.getDescription().getMoniker()); description.setDetails(message.getDescription().getDetails()); description.setIdentity(message.getDescription().getIdentity()); @@ -427,27 +488,27 @@ private Transaction convertCreateSideChainValidator(byte[] value) throws IOExcep createSideChainValidator.setDescription(description); Commission commission = new Commission(); - if (message.getCommission() != null){ + if (message.getCommission() != null) { try { commission.setRate(message.getCommission().getRate().getValue()); commission.setMaxRate(message.getCommission().getMaxRate().getValue()); commission.setMaxChangeRate(message.getCommission().getMaxChangeRate().getValue()); - }catch (NullPointerException e){ + } catch (NullPointerException e) { //ignore } } createSideChainValidator.setCommission(commission); - if (message.getDelegatorAddr() != null && message.getDelegatorAddr().getRaw() != null){ + if (message.getDelegatorAddr() != null && message.getDelegatorAddr().getRaw() != null) { createSideChainValidator.setDelegatorAddr(Crypto.encodeAddress(hrp, message.getDelegatorAddr().getRaw())); } - if (message.getValidatorOperatorAddr() != null && message.getValidatorOperatorAddr().getRaw() != null){ + if (message.getValidatorOperatorAddr() != null && message.getValidatorOperatorAddr().getRaw() != null) { createSideChainValidator.setValidatorAddr(Crypto.encodeAddress(valHrp, message.getValidatorOperatorAddr().getRaw())); } Token delegation = new Token(); - if (message.getDelegation() != null){ + if (message.getDelegation() != null) { delegation.setAmount(message.getDelegation().getAmount()); delegation.setDenom(message.getDelegation().getDenom()); } @@ -470,14 +531,13 @@ private Transaction convertCreateSideChainValidator(byte[] value) throws IOExcep } - private Transaction convertRefundHashTimerLock(byte[] value) throws InvalidProtocolBufferException { byte[] array = new byte[value.length - 4]; System.arraycopy(value, 4, array, 0, array.length); RefundHashTimerLockMsg refundHtlMsg = RefundHashTimerLockMsg.parseFrom(array); RefundHashTimerLock refundHashTimerLock = new RefundHashTimerLock(); - refundHashTimerLock.setFrom(Crypto.encodeAddress(hrp,refundHtlMsg.getFrom().toByteArray())); + refundHashTimerLock.setFrom(Crypto.encodeAddress(hrp, refundHtlMsg.getFrom().toByteArray())); refundHashTimerLock.setSwapID(Hex.toHexString(refundHtlMsg.getSwapId().toByteArray())); Transaction transaction = new Transaction(); @@ -492,7 +552,7 @@ private Transaction convertClaimHashTimerLock(byte[] value) throws InvalidProtoc ClaimHashTimerLockMsg claimHtlMsg = ClaimHashTimerLockMsg.parseFrom(array); ClaimHashTimerLock claimHashTimerLock = new ClaimHashTimerLock(); - claimHashTimerLock.setFrom(Crypto.encodeAddress(hrp,claimHtlMsg.getFrom().toByteArray())); + claimHashTimerLock.setFrom(Crypto.encodeAddress(hrp, claimHtlMsg.getFrom().toByteArray())); claimHashTimerLock.setSwapID(Hex.toHexString(claimHtlMsg.getSwapId().toByteArray())); claimHashTimerLock.setRandomNumber(Hex.toHexString(claimHtlMsg.getRandomNumber().toByteArray())); @@ -508,7 +568,7 @@ private Transaction convertDepositHashTimerLock(byte[] value) throws InvalidProt DepositHashTimerLockMsg depositHtlMsg = DepositHashTimerLockMsg.parseFrom(array); DepositHashTimerLock depositHashTimerLock = new DepositHashTimerLock(); - depositHashTimerLock.setFrom(Crypto.encodeAddress(hrp,depositHtlMsg.getFrom().toByteArray())); + depositHashTimerLock.setFrom(Crypto.encodeAddress(hrp, depositHtlMsg.getFrom().toByteArray())); depositHashTimerLock.setAmount(depositHtlMsg.getAmountList().stream().map(Token::of).collect(Collectors.toList())); depositHashTimerLock.setSwapID(Hex.toHexString(depositHtlMsg.getSwapId().toByteArray())); @@ -525,8 +585,8 @@ private Transaction convertHashTimerLockTransfer(byte[] value) throws InvalidPro HashTimerLockTransferMsg htlTransferMsg = HashTimerLockTransferMsg.parseFrom(array); HashTimerLockTransfer hashTimerLockTransfer = new HashTimerLockTransfer(); - hashTimerLockTransfer.setFrom(Crypto.encodeAddress(hrp,htlTransferMsg.getFrom().toByteArray())); - hashTimerLockTransfer.setTo(Crypto.encodeAddress(hrp,htlTransferMsg.getTo().toByteArray())); + hashTimerLockTransfer.setFrom(Crypto.encodeAddress(hrp, htlTransferMsg.getFrom().toByteArray())); + hashTimerLockTransfer.setTo(Crypto.encodeAddress(hrp, htlTransferMsg.getTo().toByteArray())); hashTimerLockTransfer.setRecipientOtherChain(htlTransferMsg.getRecipientOtherChain()); hashTimerLockTransfer.setSenderOtherChain(htlTransferMsg.getSenderOtherChain()); hashTimerLockTransfer.setRandomNumberHash(Hex.toHexString(htlTransferMsg.getRandomNumberHash().toByteArray())); @@ -547,7 +607,7 @@ private Transaction convertSetAccountFlag(byte[] value) throws InvalidProtocolBu System.arraycopy(value, 4, array, 0, array.length); com.binance.dex.api.proto.SetAccountFlag setAccountFlag = com.binance.dex.api.proto.SetAccountFlag.parseFrom(array); SetAccountFlag saf = new SetAccountFlag(); - saf.setFromAddr(Crypto.encodeAddress(hrp,setAccountFlag.getFrom().toByteArray())); + saf.setFromAddr(Crypto.encodeAddress(hrp, setAccountFlag.getFrom().toByteArray())); saf.setFlags(setAccountFlag.getFlags()); Transaction transaction = new Transaction(); transaction.setTxType(TxType.SetAccountFlag); @@ -560,7 +620,7 @@ private Transaction convertTimeRelock(byte[] value) throws InvalidProtocolBuffer System.arraycopy(value, 4, array, 0, array.length); TimeRelock timeRelock = TimeRelock.parseFrom(array); com.binance.dex.api.client.domain.broadcast.TimeRelock trl = new com.binance.dex.api.client.domain.broadcast.TimeRelock(); - trl.setFromAddr(Crypto.encodeAddress(hrp,timeRelock.getFrom().toByteArray())); + trl.setFromAddr(Crypto.encodeAddress(hrp, timeRelock.getFrom().toByteArray())); trl.setLockId(timeRelock.getTimeLockId()); trl.setLockTime(Date.from(Instant.ofEpochSecond(timeRelock.getLockTime()))); trl.setDescription(timeRelock.getDescription()); @@ -582,7 +642,7 @@ private Transaction convertTimeUnlock(byte[] value) throws InvalidProtocolBuffer System.arraycopy(value, 4, array, 0, array.length); TimeUnlock timeUnlock = TimeUnlock.parseFrom(array); com.binance.dex.api.client.domain.broadcast.TimeUnlock tul = new com.binance.dex.api.client.domain.broadcast.TimeUnlock(); - tul.setFromAddr(Crypto.encodeAddress(hrp,timeUnlock.getFrom().toByteArray())); + tul.setFromAddr(Crypto.encodeAddress(hrp, timeUnlock.getFrom().toByteArray())); tul.setLockId(timeUnlock.getTimeLockId()); Transaction transaction = new Transaction(); @@ -596,7 +656,7 @@ private Transaction convertTimeLock(byte[] value) throws InvalidProtocolBufferEx System.arraycopy(value, 4, array, 0, array.length); TimeLock timeLock = TimeLock.parseFrom(array); com.binance.dex.api.client.domain.broadcast.TimeLock tl = new com.binance.dex.api.client.domain.broadcast.TimeLock(); - tl.setFromAddr(Crypto.encodeAddress(hrp,timeLock.getFrom().toByteArray())); + tl.setFromAddr(Crypto.encodeAddress(hrp, timeLock.getFrom().toByteArray())); tl.setDescription(timeLock.getDescription()); tl.setLockTime(Date.from(Instant.ofEpochSecond(timeLock.getLockTime()))); List amount = timeLock.getAmountList().stream().map(token -> { @@ -806,10 +866,10 @@ private Transaction convertDeposit(byte[] value) throws InvalidProtocolBufferExc Deposit deposit = new Deposit(); deposit.setProposalId(depositMessage.getProposalId()); - deposit.setDepositer(Crypto.encodeAddress(hrp,depositMessage.getDepositer().toByteArray())); - if(null != depositMessage.getAmountList()){ + deposit.setDepositer(Crypto.encodeAddress(hrp, depositMessage.getDepositer().toByteArray())); + if (null != depositMessage.getAmountList()) { deposit.setAmount(depositMessage.getAmountList().stream() - .map(com.binance.dex.api.client.encoding.message.Token::of).collect(Collectors.toList())); + .map(com.binance.dex.api.client.encoding.message.Token::of).collect(Collectors.toList())); } Transaction transaction = new Transaction(); transaction.setTxType(TxType.DEPOSIT); @@ -824,8 +884,8 @@ private Transaction convertCreateValidator(byte[] value) throws InvalidProtocolB RealCreateValidator realCreateValidator = RealCreateValidator.parseFrom(array); CreateValidator createValidator = new CreateValidator(); - createValidator.setDelegatorAddress(Crypto.encodeAddress(hrp,realCreateValidator.getCreateValidator().getDelegatorAddress().toByteArray())); - createValidator.setValidatorAddress(Crypto.encodeAddress(hrp,realCreateValidator.getCreateValidator().getValidatorAddress().toByteArray())); + createValidator.setDelegatorAddress(Crypto.encodeAddress(hrp, realCreateValidator.getCreateValidator().getDelegatorAddress().toByteArray())); + createValidator.setValidatorAddress(Crypto.encodeAddress(hrp, realCreateValidator.getCreateValidator().getValidatorAddress().toByteArray())); createValidator.setDelegation(com.binance.dex.api.client.encoding.message.Token.of(realCreateValidator.getCreateValidator().getDelegation())); createValidator.setProposalId(realCreateValidator.getProposalId()); @@ -841,9 +901,9 @@ private Transaction convertRemoveValidator(byte[] value) throws InvalidProtocolB com.binance.dex.api.proto.RemoveValidator removeValidatorMessage = com.binance.dex.api.proto.RemoveValidator.parseFrom(array); RemoveValidator removeValidator = new RemoveValidator(); - removeValidator.setLauncherAddr(Crypto.encodeAddress(hrp,removeValidatorMessage.getLauncherAddr().toByteArray())); - removeValidator.setValAddr(Crypto.encodeAddress(hrp,removeValidatorMessage.getValAddr().toByteArray())); - removeValidator.setValConsAddr(Crypto.encodeAddress(hrp,removeValidatorMessage.getValConsAddr().toByteArray())); + removeValidator.setLauncherAddr(Crypto.encodeAddress(hrp, removeValidatorMessage.getLauncherAddr().toByteArray())); + removeValidator.setValAddr(Crypto.encodeAddress(hrp, removeValidatorMessage.getValAddr().toByteArray())); + removeValidator.setValConsAddr(Crypto.encodeAddress(hrp, removeValidatorMessage.getValConsAddr().toByteArray())); removeValidator.setProposalId(removeValidatorMessage.getProposalId()); Transaction transaction = new Transaction(); @@ -863,7 +923,7 @@ private Transaction convertListing(byte[] value) throws InvalidProtocolBufferExc listing.setBaseAssetSymbol(listMessage.getBaseAssetSymbol()); listing.setQuoteAssetSymbol(listMessage.getQuoteAssetSymbol()); listing.setInitPrice(listMessage.getInitPrice()); - listing.setFromAddr(Crypto.encodeAddress(hrp,listMessage.getFrom().toByteArray())); + listing.setFromAddr(Crypto.encodeAddress(hrp, listMessage.getFrom().toByteArray())); Transaction transaction = new Transaction(); transaction.setTxType(TxType.LISTING); diff --git a/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java b/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java index e3d6576..532fb26 100644 --- a/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java +++ b/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java @@ -30,5 +30,7 @@ public enum TxType { SIDECHAIN_UNBOND, CLAIM, TRANSFER_OUT, - BIND + BIND, + BSC_SUBMIT_EVIDENCE, + SIDECHAIN_UNJAIL } diff --git a/src/main/java/com/binance/dex/api/client/domain/slash/BscHeader.java b/src/main/java/com/binance/dex/api/client/domain/slash/BscHeader.java new file mode 100644 index 0000000..4b8f087 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/slash/BscHeader.java @@ -0,0 +1,57 @@ +package com.binance.dex.api.client.domain.slash; + +import com.binance.dex.api.client.encoding.serializer.BytesToPrefixedHexStringSerializer; +import com.binance.dex.api.client.encoding.serializer.LongToHexStringSerializer; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +public class BscHeader { + + @JsonSerialize(using = BytesToPrefixedHexStringSerializer.class) + private byte[] parentHash; + + @JsonSerialize(using = BytesToPrefixedHexStringSerializer.class) + private byte[] sha3Uncles; + + @JsonSerialize(using = BytesToPrefixedHexStringSerializer.class) + private byte[] miner; + + @JsonSerialize(using = BytesToPrefixedHexStringSerializer.class) + private byte[] stateRoot; + + @JsonSerialize(using = BytesToPrefixedHexStringSerializer.class) + private byte[] transactionsRoot; + + @JsonSerialize(using = BytesToPrefixedHexStringSerializer.class) + private byte[] receiptsRoot; + + @JsonSerialize(using = BytesToPrefixedHexStringSerializer.class) + private byte[] logsBloom; + + @JsonSerialize(using = LongToHexStringSerializer.class) + private Long difficulty; + + @JsonSerialize(using = LongToHexStringSerializer.class) + private Long number; + + @JsonSerialize(using = LongToHexStringSerializer.class) + private Long gasLimit; + + @JsonSerialize(using = LongToHexStringSerializer.class) + private Long gasUsed; + + @JsonSerialize(using = LongToHexStringSerializer.class) + private Long timestamp; + + @JsonSerialize(using = BytesToPrefixedHexStringSerializer.class) + private byte[] extra; + + @JsonSerialize(using = BytesToPrefixedHexStringSerializer.class) + private byte[] mixHash; + + @JsonSerialize(using = BytesToPrefixedHexStringSerializer.class) + private byte[] nonce; +} diff --git a/src/main/java/com/binance/dex/api/client/domain/slash/BscSubmitEvidence.java b/src/main/java/com/binance/dex/api/client/domain/slash/BscSubmitEvidence.java new file mode 100644 index 0000000..02f0961 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/slash/BscSubmitEvidence.java @@ -0,0 +1,13 @@ +package com.binance.dex.api.client.domain.slash; + +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +public class BscSubmitEvidence { + + private String submitter; + + private BscHeader[] headers; +} diff --git a/src/main/java/com/binance/dex/api/client/domain/slash/SideChainUnJail.java b/src/main/java/com/binance/dex/api/client/domain/slash/SideChainUnJail.java new file mode 100644 index 0000000..89426e2 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/slash/SideChainUnJail.java @@ -0,0 +1,14 @@ +package com.binance.dex.api.client.domain.slash; + +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +public class SideChainUnJail { + + private String validatorAddr; + + private String sideChainId; + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java b/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java index a37bf2c..afbc2da 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java @@ -40,7 +40,10 @@ public enum MessageType { SideChainUndelegate("514F7E0E"), Claim("175A0521"), TransferOut("800819C0"), - Bind("B9AE640C"); + Bind("B9AE640C"), + BscSubmitEvidence("A38F1399"), + SideChainUnJail("5681EC54"); + private byte[] typePrefixBytes; MessageType(String typePrefix) { diff --git a/src/main/java/com/binance/dex/api/client/encoding/serializer/BytesToPrefixedHexStringSerializer.java b/src/main/java/com/binance/dex/api/client/encoding/serializer/BytesToPrefixedHexStringSerializer.java new file mode 100644 index 0000000..8533911 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/serializer/BytesToPrefixedHexStringSerializer.java @@ -0,0 +1,18 @@ +package com.binance.dex.api.client.encoding.serializer; + +import com.binance.dex.api.client.encoding.EncodeUtils; +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.databind.JsonSerializer; +import com.fasterxml.jackson.databind.SerializerProvider; + +import java.io.IOException; + +public class BytesToPrefixedHexStringSerializer extends JsonSerializer { + + @Override + public void serialize(byte[] bytes, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { + if(bytes != null){ + jsonGenerator.writeString("0x" + EncodeUtils.bytesToHex(bytes)); + } + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/serializer/LongToHexStringSerializer.java b/src/main/java/com/binance/dex/api/client/encoding/serializer/LongToHexStringSerializer.java new file mode 100644 index 0000000..5f2a433 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/serializer/LongToHexStringSerializer.java @@ -0,0 +1,17 @@ +package com.binance.dex.api.client.encoding.serializer; + +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.databind.JsonSerializer; +import com.fasterxml.jackson.databind.SerializerProvider; + +import java.io.IOException; + +public class LongToHexStringSerializer extends JsonSerializer { + + @Override + public void serialize(Long aLong, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { + if (aLong != null) { + jsonGenerator.writeString("0x" + Long.toHexString(aLong)); + } + } +} diff --git a/src/main/proto/dex.proto b/src/main/proto/dex.proto index 0cddd20..2fe5664 100644 --- a/src/main/proto/dex.proto +++ b/src/main/proto/dex.proto @@ -342,6 +342,36 @@ message ClaimHashTimerLockMsg { bytes random_number = 3; } +message SubmitEvidenceMsg { + // A38F1399 + bytes submitter = 1; + repeated BscHeader headers = 2; +} + +message BscHeader { + bytes parentHash = 1; + bytes sha3Uncles = 2; + bytes miner = 3; + bytes stateRoot = 4; + bytes transactionsRoot = 5; + bytes receiptsRoot = 6; + bytes logsBloom = 7; + int64 difficulty = 8; + int64 number = 9; + int64 gasLimit = 10; + int64 gasUsed = 11; + int64 timestamp = 12; + bytes extraData = 13; + bytes mixHash = 14; + bytes nonce = 15; +} + +message SideChainUnJailMsg { + // 5681EC54 + bytes address = 1; + string side_chain_id = 2; +} + message RefundHashTimerLockMsg { // bytes from = 1; From 8a8ade3f2fdbbd01197ae5e582932c0d32e787e8 Mon Sep 17 00:00:00 2001 From: FitzLu Date: Thu, 30 Apr 2020 16:58:03 +0800 Subject: [PATCH 05/52] modify staking query --- .../api/client/domain/stake/Description.java | 12 +- .../domain/stake/sidechain/Delegation.java | 40 ++++++ .../stake/sidechain/SideChainDelegate.java | 3 +- .../stake/sidechain/SideChainDelegation.java | 60 ++------ .../dex/api/client/encoding/ByteUtil.java | 28 +++- .../dex/api/client/encoding/Crypto.java | 12 -- .../dex/api/client/encoding/EncodeUtils.java | 4 + .../client/encoding/amino/DisambPrefix.java | 2 +- .../client/encoding/amino/InternalAmino.java | 6 +- .../message/TransactionRequestAssembler.java | 3 +- .../encoding/message/bridge/ClaimTypes.java | 5 +- .../message/sidechain/SideChainIds.java | 10 ++ .../sidechain/query/BaseQueryParams.java | 2 +- .../message/sidechain/query/Delegation.java | 55 +++++++ .../sidechain/query/DelegationResponse.java | 44 ++++++ .../sidechain/query/QueryBondsParams.java | 46 ++++++ .../sidechain/query/QueryDelegatorParams.java | 20 +++ .../query/QueryTopValidatorParams.java | 13 +- .../sidechain/query/QueryValidatorParams.java | 13 +- .../sidechain/value/CommissionValue.java | 36 +++-- .../BytesToPrefixedHexStringSerializer.java | 2 +- ...{NodeQueryDelegate.java => NodeQuery.java} | 4 +- .../impl/node/NodeQueryDelegateOracle.java | 2 +- .../NodeQueryDelegateSideChainStaking.java | 121 ++++++++-------- .../node/{NodeTxDelegate.java => NodeTx.java} | 4 +- .../impl/node/NodeTxDelegateBridge.java | 2 +- .../node/NodeTxDelegateSideChainStaking.java | 2 +- .../dex/api/client/encoding/AminoTest.java | 20 ++- .../client/examples/BridgeNodeExample.java | 99 ++++--------- .../examples/SideChainStakingNodeExample.java | 135 +++++++----------- 30 files changed, 458 insertions(+), 347 deletions(-) create mode 100644 src/main/java/com/binance/dex/api/client/domain/stake/sidechain/Delegation.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/SideChainIds.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/Delegation.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/DelegationResponse.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryBondsParams.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryDelegatorParams.java rename src/main/java/com/binance/dex/api/client/impl/node/{NodeQueryDelegate.java => NodeQuery.java} (97%) rename src/main/java/com/binance/dex/api/client/impl/node/{NodeTxDelegate.java => NodeTx.java} (98%) diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/Description.java b/src/main/java/com/binance/dex/api/client/domain/stake/Description.java index d5f4562..dd09ce9 100644 --- a/src/main/java/com/binance/dex/api/client/domain/stake/Description.java +++ b/src/main/java/com/binance/dex/api/client/domain/stake/Description.java @@ -5,15 +5,19 @@ **/ public class Description { - private String moniker = ""; + private String moniker; - private String identity = ""; + private String identity; - private String website = ""; + private String website; - private String details = ""; + private String details; public Description() { + this.moniker = ""; + this.identity = ""; + this.website = ""; + this.details = ""; } public Description(String moniker, String identity, String website, String details) { diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/Delegation.java b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/Delegation.java new file mode 100644 index 0000000..94b3ef5 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/Delegation.java @@ -0,0 +1,40 @@ +package com.binance.dex.api.client.domain.stake.sidechain; + +/** + * @author Fitz.Lu + **/ +public class Delegation { + + private String delegatorAddress; + + private String validatorAddress; + + private long shares; + + public Delegation() { + } + + public String getDelegatorAddress() { + return delegatorAddress; + } + + public void setDelegatorAddress(String delegatorAddress) { + this.delegatorAddress = delegatorAddress; + } + + public String getValidatorAddress() { + return validatorAddress; + } + + public void setValidatorAddress(String validatorAddress) { + this.validatorAddress = validatorAddress; + } + + public long getShares() { + return shares; + } + + public void setShares(long shares) { + this.shares = shares; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainDelegate.java b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainDelegate.java index a9045f6..85c8aaf 100644 --- a/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainDelegate.java +++ b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainDelegate.java @@ -13,9 +13,10 @@ public class SideChainDelegate { private Token delegation; - private String sideChainId = ""; + private String sideChainId; public SideChainDelegate() { + sideChainId = ""; } public SideChainDelegate(String delegatorAddress, String validatorAddress, Token delegation, String sideChainId) { diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainDelegation.java b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainDelegation.java index b4e5b4b..9a07436 100644 --- a/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainDelegation.java +++ b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainDelegation.java @@ -1,69 +1,37 @@ package com.binance.dex.api.client.domain.stake.sidechain; -import java.util.Arrays; +import com.binance.dex.api.client.encoding.message.Token; /** * @author Fitz.Lu **/ public class SideChainDelegation { - private String delegatorAddress; + private Delegation delegation; - private String validatorAddress; - - private long shares; - - private long height; + private Token balance; public SideChainDelegation() { } - public SideChainDelegation(String delegatorAddress, String validatorAddress, long shares, long height) { - this.delegatorAddress = delegatorAddress; - this.validatorAddress = validatorAddress; - this.shares = shares; - this.height = height; - } - - public String getDelegatorAddress() { - return delegatorAddress; - } - - public void setDelegatorAddress(String delegatorAddress) { - this.delegatorAddress = delegatorAddress; - } - - public String getValidatorAddress() { - return validatorAddress; - } - - public void setValidatorAddress(String validatorAddress) { - this.validatorAddress = validatorAddress; - } - - public long getShares() { - return shares; + public SideChainDelegation(Delegation delegation, Token balance) { + this.delegation = delegation; + this.balance = balance; } - public void setShares(long shares) { - this.shares = shares; + public Delegation getDelegation() { + return delegation; } - public long getHeight() { - return height; + public void setDelegation(Delegation delegation) { + this.delegation = delegation; } - public void setHeight(long height) { - this.height = height; + public Token getBalance() { + return balance; } - @Override - public String toString() { - return "SideChainDelegation{" + - "delegatorAddress=" + delegatorAddress + - ", validatorAddress=" + validatorAddress + - ", shares=" + shares + - ", height=" + height + - '}'; + public void setBalance(Token balance) { + this.balance = balance; } } diff --git a/src/main/java/com/binance/dex/api/client/encoding/ByteUtil.java b/src/main/java/com/binance/dex/api/client/encoding/ByteUtil.java index 4fe70f3..005dfc7 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/ByteUtil.java +++ b/src/main/java/com/binance/dex/api/client/encoding/ByteUtil.java @@ -3,7 +3,6 @@ /** * @author Fitz.Lu **/ -//TODO add safe check public class ByteUtil { public static boolean isEmpty(byte[] bytes){ @@ -11,28 +10,55 @@ public static boolean isEmpty(byte[] bytes){ } public static byte[] read(byte[] bytes, int length){ + requireByteArrayNotEmpty(bytes); + byte[] newBytes = new byte[length]; System.arraycopy(bytes, 0, newBytes, 0, length); return newBytes; } public static byte[] cut(byte[] bytes, int length){ + requireByteArrayNotEmpty(bytes); + requireByteArrayLengthNotLessThan(bytes, length); + byte[] newBytes = new byte[bytes.length - length]; System.arraycopy(bytes, length, newBytes, 0, newBytes.length); return newBytes; } public static byte[] pick(byte[] bytes, int start, int length){ + requireByteArrayNotEmpty(bytes); + requireByteArrayLengthNotLessThan(bytes, length); + byte[] newBytes = new byte[length]; System.arraycopy(bytes, start, newBytes, 0, length); return newBytes; } public static byte[] appendBytesArray(byte[] first, byte[] second){ + if (first == null){ + throw new NullPointerException("first byte array is null"); + } + if (second == null){ + throw new NullPointerException("second byte array is null"); + } + byte[] newArray = new byte[first.length + second.length]; System.arraycopy(first, 0, newArray, 0, first.length); System.arraycopy(second, 0, newArray, first.length, second.length); return newArray; } + public static void requireByteArrayNotEmpty(byte[] bytes){ + if (isEmpty(bytes)){ + throw new IllegalArgumentException("Input byte array is null or empty"); + } + } + + public static void requireByteArrayLengthNotLessThan(byte[] bytes, int length){ + if (bytes.length < length){ + throw new IllegalArgumentException("Input byte array length is less than " + length); + } + } + } diff --git a/src/main/java/com/binance/dex/api/client/encoding/Crypto.java b/src/main/java/com/binance/dex/api/client/encoding/Crypto.java index 7e9f426..e9b08fc 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/Crypto.java +++ b/src/main/java/com/binance/dex/api/client/encoding/Crypto.java @@ -185,16 +185,4 @@ public static class SegwitAddressException extends IllegalArgumentException { } } - public static String encodeEthAddress(byte[] address){ - return "0x" + Hex.toHexString(address); - } - - public static byte[] decodeEthAddress(String address){ - String addr = address; - if (addr.startsWith("0x")){ - addr = address.substring(2); - } - return Hex.decode(addr); - } - } diff --git a/src/main/java/com/binance/dex/api/client/encoding/EncodeUtils.java b/src/main/java/com/binance/dex/api/client/encoding/EncodeUtils.java index 50faaee..cb9327a 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/EncodeUtils.java +++ b/src/main/java/com/binance/dex/api/client/encoding/EncodeUtils.java @@ -26,6 +26,10 @@ public static String bytesToHex(byte[] bytes) { return Hex.toHexString(bytes); } + public static String bytesToPrefixHex(byte[] bytes) { + return "0x" + bytesToHex(bytes); + } + public static String toJsonStringSortKeys(Object object) throws JsonProcessingException { return OBJECT_MAPPER.writeValueAsString(object); } diff --git a/src/main/java/com/binance/dex/api/client/encoding/amino/DisambPrefix.java b/src/main/java/com/binance/dex/api/client/encoding/amino/DisambPrefix.java index 3b94326..f987823 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/amino/DisambPrefix.java +++ b/src/main/java/com/binance/dex/api/client/encoding/amino/DisambPrefix.java @@ -18,7 +18,7 @@ public class DisambPrefix { private byte[] prefix; /** - * You know it + * disamb bytes append prefix bytes * */ private byte[] disambPrefix; diff --git a/src/main/java/com/binance/dex/api/client/encoding/amino/InternalAmino.java b/src/main/java/com/binance/dex/api/client/encoding/amino/InternalAmino.java index 9169e84..d85f506 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/amino/InternalAmino.java +++ b/src/main/java/com/binance/dex/api/client/encoding/amino/InternalAmino.java @@ -3,11 +3,11 @@ /** * @author Fitz.Lu **/ -class InternalAmino { +public class InternalAmino { - static final Amino ins = new Amino(); + private static final Amino ins = new Amino(); - static Amino get(){ + public static Amino get(){ return ins; } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/TransactionRequestAssembler.java b/src/main/java/com/binance/dex/api/client/encoding/message/TransactionRequestAssembler.java index 290f4b4..2f05283 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/TransactionRequestAssembler.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/TransactionRequestAssembler.java @@ -6,6 +6,7 @@ import com.binance.dex.api.client.encoding.EncodeUtils; import com.binance.dex.api.client.encoding.amino.Amino; import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.amino.InternalAmino; import com.binance.dex.api.client.encoding.amino.WireType; import com.binance.dex.api.proto.StdSignature; import com.binance.dex.api.proto.StdTx; @@ -36,7 +37,7 @@ public class TransactionRequestAssembler { public TransactionRequestAssembler(Wallet wallet, TransactionOption options) { this.wallet = wallet; this.options = options; - this.amino = new Amino(); + this.amino = InternalAmino.get(); } public static long doubleToLong(String d) { diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/ClaimTypes.java b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/ClaimTypes.java index 60a423d..3021a28 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/ClaimTypes.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/ClaimTypes.java @@ -1,6 +1,7 @@ package com.binance.dex.api.client.encoding.message.bridge; import java.util.HashMap; +import java.util.Map; /** * @author Fitz.Lu @@ -17,8 +18,8 @@ public class ClaimTypes { private static final String ClaimTypeUpdateTransferOutName = "UpdateTransferOut"; private static final String ClaimTypeTransferInName = "TransferIn"; - private static final HashMap claimTypeToName; - private static final HashMap claimNameToType; + private static final Map claimTypeToName; + private static final Map claimNameToType; static { claimTypeToName = new HashMap<>(); diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/SideChainIds.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/SideChainIds.java new file mode 100644 index 0000000..2581a25 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/SideChainIds.java @@ -0,0 +1,10 @@ +package com.binance.dex.api.client.encoding.message.sidechain; + +/** + * @author Fitz.Lu + **/ +public class SideChainIds { + + public static final String BSC = "bsc"; + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/BaseQueryParams.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/BaseQueryParams.java index f1a24b0..fe72e8f 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/BaseQueryParams.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/BaseQueryParams.java @@ -8,7 +8,7 @@ public class BaseQueryParams { @JsonProperty(value = "SideChainId") - private String sideChainId; + protected String sideChainId; public BaseQueryParams() { } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/Delegation.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/Delegation.java new file mode 100644 index 0000000..f6a3d8e --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/Delegation.java @@ -0,0 +1,55 @@ +package com.binance.dex.api.client.encoding.message.sidechain.query; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; + +/** + * @author Fitz.Lu + **/ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class Delegation { + + @JsonProperty(value = "delegator_addr") + private String delegatorAddress; + + @JsonProperty(value = "validator_addr") + private String validatorAddress; + + @JsonProperty(value = "shares") + private long shares; + + public Delegation() { + } + + public Delegation(String delegatorAddress, String validatorAddress, long shares) { + this.delegatorAddress = delegatorAddress; + this.validatorAddress = validatorAddress; + this.shares = shares; + } + + public String getDelegatorAddress() { + return delegatorAddress; + } + + public void setDelegatorAddress(String delegatorAddress) { + this.delegatorAddress = delegatorAddress; + } + + public String getValidatorAddress() { + return validatorAddress; + } + + public void setValidatorAddress(String validatorAddress) { + this.validatorAddress = validatorAddress; + } + + public long getShares() { + return shares; + } + + public void setShares(long shares) { + this.shares = shares; + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/DelegationResponse.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/DelegationResponse.java new file mode 100644 index 0000000..fe2c785 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/DelegationResponse.java @@ -0,0 +1,44 @@ +package com.binance.dex.api.client.encoding.message.sidechain.query; + +import com.binance.dex.api.client.encoding.message.common.CoinValue; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; + +/** + * @author Fitz.Lu + **/ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class DelegationResponse { + + @JsonProperty(value = "Delegation") + private Delegation delegation; + + @JsonProperty(value = "balance") + private CoinValue balance; + + public DelegationResponse() { + } + + public DelegationResponse(Delegation delegation, CoinValue balance) { + this.delegation = delegation; + this.balance = balance; + } + + public Delegation getDelegation() { + return delegation; + } + + public void setDelegation(Delegation delegation) { + this.delegation = delegation; + } + + public CoinValue getBalance() { + return balance; + } + + public void setBalance(CoinValue balance) { + this.balance = balance; + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryBondsParams.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryBondsParams.java new file mode 100644 index 0000000..ff5a905 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryBondsParams.java @@ -0,0 +1,46 @@ +package com.binance.dex.api.client.encoding.message.sidechain.query; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; + +/** + * @author Fitz.Lu + **/ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class QueryBondsParams extends BaseQueryParams { + + @JsonProperty(value = "DelegatorAddr") + private String delegatorAddr; + + @JsonProperty(value = "ValidatorAddr") + private String validatorAddr; + + public QueryBondsParams() { + } + + public String getSideChainId() { + return sideChainId; + } + + public void setSideChainId(String sideChainId) { + this.sideChainId = sideChainId; + } + + public String getDelegatorAddr() { + return delegatorAddr; + } + + public void setDelegatorAddr(String delegatorAddr) { + this.delegatorAddr = delegatorAddr; + } + + public String getValidatorAddr() { + return validatorAddr; + } + + public void setValidatorAddr(String validatorAddr) { + this.validatorAddr = validatorAddr; + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryDelegatorParams.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryDelegatorParams.java new file mode 100644 index 0000000..ce4bf3f --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryDelegatorParams.java @@ -0,0 +1,20 @@ +package com.binance.dex.api.client.encoding.message.sidechain.query; + +import com.fasterxml.jackson.annotation.JsonProperty; + +/** + * @author Fitz.Lu + **/ +public class QueryDelegatorParams extends BaseQueryParams { + + @JsonProperty(value = "DelegatorAddr") + private String delegatorAddr; + + public String getDelegatorAddr() { + return delegatorAddr; + } + + public void setDelegatorAddr(String delegatorAddr) { + this.delegatorAddr = delegatorAddr; + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryTopValidatorParams.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryTopValidatorParams.java index 0d7189c..44dfacf 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryTopValidatorParams.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryTopValidatorParams.java @@ -5,10 +5,7 @@ /** * @author Fitz.Lu **/ -public class QueryTopValidatorParams { - - @JsonProperty(value = "SideChainId") - private String sideChainId; +public class QueryTopValidatorParams extends BaseQueryParams { @JsonProperty(value = "Top") private int top; @@ -16,14 +13,6 @@ public class QueryTopValidatorParams { public QueryTopValidatorParams() { } - public String getSideChainId() { - return sideChainId; - } - - public void setSideChainId(String sideChainId) { - this.sideChainId = sideChainId; - } - public int getTop() { return top; } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryValidatorParams.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryValidatorParams.java index 9e75cc1..6ec08ac 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryValidatorParams.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryValidatorParams.java @@ -8,10 +8,7 @@ /** * @author Fitz.Lu **/ -public class QueryValidatorParams { - - @JsonProperty(value = "SideChainId") - private String sideChainId; +public class QueryValidatorParams extends BaseQueryParams { @JsonProperty(value = "ValidatorAddr") @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) @@ -25,14 +22,6 @@ public QueryValidatorParams(String sideChainId, Bech32AddressValue validatorAddr ValidatorAddress = validatorAddress; } - public String getSideChainId() { - return sideChainId; - } - - public void setSideChainId(String sideChainId) { - this.sideChainId = sideChainId; - } - public Bech32AddressValue getValidatorAddress() { return ValidatorAddress; } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/CommissionValue.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/CommissionValue.java index 6c4eb72..f760a51 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/CommissionValue.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/value/CommissionValue.java @@ -3,9 +3,12 @@ import com.binance.dex.api.client.encoding.amino.AminoField; import com.binance.dex.api.client.encoding.amino.AminoSerializable; import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; +import com.binance.dex.api.client.encoding.message.common.Dec; +import com.binance.dex.api.client.encoding.serializer.DecToStringSerializer; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; import java.util.ArrayList; @@ -17,38 +20,41 @@ public class CommissionValue implements BinanceDexTransactionMessage, AminoSerializable { @JsonProperty(value = "rate") - private long rate; + @JsonSerialize(using = DecToStringSerializer.class) + private Dec rate = Dec.newInstance(0L); @JsonProperty(value = "max_rate") - private long maxRate; + @JsonSerialize(using = DecToStringSerializer.class) + private Dec maxRate = Dec.newInstance(0L); @JsonProperty(value = "max_change_rate") - private long maxChangeRate; + @JsonSerialize(using = DecToStringSerializer.class) + private Dec maxChangeRate = Dec.newInstance(0L); @JsonProperty(value = "update_time") private TimestampValue updateTime; - public long getRate() { + public Dec getRate() { return rate; } - public void setRate(long rate) { + public void setRate(Dec rate) { this.rate = rate; } - public long getMaxRate() { + public Dec getMaxRate() { return maxRate; } - public void setMaxRate(long maxRate) { + public void setMaxRate(Dec maxRate) { this.maxRate = maxRate; } - public long getMaxChangeRate() { + public Dec getMaxChangeRate() { return maxChangeRate; } - public void setMaxChangeRate(long maxChangeRate) { + public void setMaxChangeRate(Dec maxChangeRate) { this.maxChangeRate = maxChangeRate; } @@ -79,9 +85,9 @@ public AminoSerializable newAminoMessage() { @Override public ArrayList> IterateFields() { return AminoField.newFieldsBuilder() - .addField(Long.class, rate, rate == 0) - .addField(Long.class, maxRate, maxRate == 0) - .addField(Long.class, maxChangeRate, maxChangeRate == 0) + .addField(Dec.class, rate, rate == null || rate.isDefaultOrEmpty()) + .addField(Dec.class, maxRate, maxRate == null || maxRate.isDefaultOrEmpty()) + .addField(Dec.class, maxChangeRate, maxChangeRate == null || maxChangeRate.isDefaultOrEmpty()) .addField(TimestampValue.class, updateTime, false) .build(); } @@ -90,13 +96,13 @@ public ArrayList> IterateFields() { public void setValueByFieldIndex(int fieldIndex, Object value) { switch (fieldIndex) { case 1: - rate = ((Long) value); + rate = ((Dec) value); break; case 2: - maxRate = ((Long) value); + maxRate = ((Dec) value); break; case 3: - maxChangeRate = ((Long) value); + maxChangeRate = ((Dec) value); break; case 4: updateTime = ((TimestampValue) value); diff --git a/src/main/java/com/binance/dex/api/client/encoding/serializer/BytesToPrefixedHexStringSerializer.java b/src/main/java/com/binance/dex/api/client/encoding/serializer/BytesToPrefixedHexStringSerializer.java index 8533911..67d2eda 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/serializer/BytesToPrefixedHexStringSerializer.java +++ b/src/main/java/com/binance/dex/api/client/encoding/serializer/BytesToPrefixedHexStringSerializer.java @@ -12,7 +12,7 @@ public class BytesToPrefixedHexStringSerializer extends JsonSerializer { @Override public void serialize(byte[] bytes, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { if(bytes != null){ - jsonGenerator.writeString("0x" + EncodeUtils.bytesToHex(bytes)); + jsonGenerator.writeString(EncodeUtils.bytesToPrefixHex(bytes)); } } } diff --git a/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegate.java b/src/main/java/com/binance/dex/api/client/impl/node/NodeQuery.java similarity index 97% rename from src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegate.java rename to src/main/java/com/binance/dex/api/client/impl/node/NodeQuery.java index ea92518..9343ee3 100644 --- a/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegate.java +++ b/src/main/java/com/binance/dex/api/client/impl/node/NodeQuery.java @@ -19,7 +19,7 @@ /** * @author Fitz.Lu **/ -class NodeQueryDelegate { +class NodeQuery { private final BinanceDexNodeApi binanceDexNodeApi; @@ -27,7 +27,7 @@ class NodeQueryDelegate { protected final String valHrp; - public NodeQueryDelegate(BinanceDexNodeApi binanceDexNodeApi, String hrp, String valHrp) { + public NodeQuery(BinanceDexNodeApi binanceDexNodeApi, String hrp, String valHrp) { this.binanceDexNodeApi = binanceDexNodeApi; this.hrp = hrp; this.valHrp = valHrp; diff --git a/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegateOracle.java b/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegateOracle.java index eb19164..4bbd1f4 100644 --- a/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegateOracle.java +++ b/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegateOracle.java @@ -20,7 +20,7 @@ /** * @author Fitz.Lu **/ -public class NodeQueryDelegateOracle extends NodeQueryDelegate { +public class NodeQueryDelegateOracle extends NodeQuery { private static final String oracleStoreName = "oracle"; diff --git a/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegateSideChainStaking.java b/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegateSideChainStaking.java index c37b79c..1f7abe7 100644 --- a/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegateSideChainStaking.java +++ b/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegateSideChainStaking.java @@ -5,32 +5,31 @@ import com.binance.dex.api.client.domain.stake.Description; import com.binance.dex.api.client.domain.stake.Pool; import com.binance.dex.api.client.domain.stake.sidechain.*; +import com.binance.dex.api.client.domain.stake.sidechain.Delegation; import com.binance.dex.api.client.encoding.ByteUtil; import com.binance.dex.api.client.encoding.Crypto; import com.binance.dex.api.client.encoding.EncodeUtils; import com.binance.dex.api.client.encoding.amino.Amino; +import com.binance.dex.api.client.encoding.amino.InternalAmino; import com.binance.dex.api.client.encoding.amino.WireType; import com.binance.dex.api.client.encoding.message.Token; import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; import com.binance.dex.api.client.encoding.message.common.CoinValue; import com.binance.dex.api.client.encoding.message.sidechain.query.*; -import com.binance.dex.api.client.encoding.message.sidechain.value.DelegationValue; import com.binance.dex.api.client.encoding.message.sidechain.value.RedelegationValue; import com.binance.dex.api.client.encoding.message.sidechain.value.UnBondingValue; import com.fasterxml.jackson.core.type.TypeReference; import com.google.common.base.Charsets; import java.io.IOException; -import java.nio.ByteBuffer; import java.nio.charset.Charset; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; /** * @author Fitz.Lu **/ -public class NodeQueryDelegateSideChainStaking extends NodeQueryDelegate { +public class NodeQueryDelegateSideChainStaking extends NodeQuery { private final String stakeStoreName = "stake"; private final String scStoreKey = "sc"; @@ -50,16 +49,12 @@ public class NodeQueryDelegateSideChainStaking extends NodeQueryDelegate { public NodeQueryDelegateSideChainStaking(BinanceDexNodeApi binanceDexNodeApi, String hrp, String valHrp) { super(binanceDexNodeApi, hrp, valHrp); - amino = new Amino(); + amino = InternalAmino.get(); } public SideChainValidator querySideChainValidator(String sideChainId, String validatorAddress) throws IOException { byte[] storePrefix = getSideChainStorePrefixKey(sideChainId); - byte[] keyPrefix = queryStore(stakeStoreName, storePrefix); - if (keyPrefix == null) { - keyPrefix = new byte[0]; - } - byte[] key = ByteUtil.appendBytesArray(keyPrefix, getValidatorKey(Crypto.decodeAddress(validatorAddress))); + byte[] key = ByteUtil.appendBytesArray(storePrefix, getValidatorKey(Crypto.decodeAddress(validatorAddress))); byte[] result = queryStore(stakeStoreName, key); if (result != null) { @@ -101,25 +96,27 @@ private SideChainValidator convert(SideChainValidatorMessage message){ SideChainValidator sideChainValidator = new SideChainValidator(); if (message.getFeeAddr() != null) { - sideChainValidator.setFeeAddr(Crypto.encodeEthAddress(message.getFeeAddr())); + sideChainValidator.setFeeAddr(EncodeUtils.bytesToPrefixHex(message.getFeeAddr())); } if (message.getOperatorAddr() != null) { sideChainValidator.setOperatorAddr(Crypto.encodeAddress(valHrp, message.getOperatorAddr())); } //TODO consPubKey use amino decode with type prefix - boolean fallBack = true; - byte[] typePrefix = ByteUtil.pick(message.getConsPubKey(), 0, 4); - if (WireType.isRegistered(typePrefix)){ - byte length = ByteUtil.pick(message.getConsPubKey(), 4, 1)[0]; - int len = Byte.toUnsignedInt(length); - if (message.getConsPubKey().length - 5 == len){ - sideChainValidator.setConsPubKey(ByteUtil.cut(message.getConsPubKey(), 5)); - fallBack = false; + if (message.getConsPubKey() != null) { + boolean fallBack = true; + byte[] typePrefix = ByteUtil.pick(message.getConsPubKey(), 0, 4); + if (WireType.isRegistered(typePrefix)) { + byte length = ByteUtil.pick(message.getConsPubKey(), 4, 1)[0]; + int len = Byte.toUnsignedInt(length); + if (message.getConsPubKey().length - 5 == len) { + sideChainValidator.setConsPubKey(ByteUtil.cut(message.getConsPubKey(), 5)); + fallBack = false; + } + } + if (fallBack) { + sideChainValidator.setConsPubKey(message.getConsPubKey()); } - } - if (fallBack) { - sideChainValidator.setConsPubKey(message.getConsPubKey()); } if (message.getDistributionAddr() != null){ @@ -147,71 +144,79 @@ private SideChainValidator convert(SideChainValidatorMessage message){ Commission commission = new Commission(); if (message.getCommission() != null) { - commission.setRate(message.getCommission().getRate()); - commission.setMaxRate(message.getCommission().getMaxRate()); - commission.setMaxChangeRate(message.getCommission().getMaxChangeRate()); + if (message.getCommission().getRate() != null) { + commission.setRate(message.getCommission().getRate().getValue()); + } + if (message.getCommission().getMaxRate() != null) { + commission.setMaxRate(message.getCommission().getMaxRate().getValue()); + } + if (message.getCommission().getMaxChangeRate() != null) { + commission.setMaxChangeRate(message.getCommission().getMaxChangeRate().getValue()); + } } sideChainValidator.setCommission(commission); sideChainValidator.setSideChainId(message.getSideChainId()); if (message.getSideConsAddr() != null) { - sideChainValidator.setSideConsAddr(Crypto.encodeEthAddress(message.getSideConsAddr())); + sideChainValidator.setSideConsAddr(EncodeUtils.bytesToPrefixHex(message.getSideConsAddr())); } if (message.getSideFeeAddr() != null) { - sideChainValidator.setSideFeeAddr(Crypto.encodeEthAddress(message.getSideFeeAddr())); + sideChainValidator.setSideFeeAddr(EncodeUtils.bytesToPrefixHex(message.getSideFeeAddr())); } return sideChainValidator; } public SideChainDelegation querySideChainDelegation(String sideChainId, String delegatorAddress, String validatorAddress) throws IOException { - byte[] storePrefix = getSideChainStorePrefixKey(sideChainId); - byte[] delegationKey = getDelegationKey(Crypto.decodeAddress(delegatorAddress), Crypto.decodeAddress(validatorAddress)); + QueryBondsParams params = new QueryBondsParams(); + params.setSideChainId(sideChainId); + params.setDelegatorAddr(delegatorAddress); + params.setValidatorAddr(validatorAddress); - byte[] key = ByteUtil.appendBytesArray(storePrefix, delegationKey); - byte[] result = queryStore(stakeStoreName, key); + byte[] paramsBytes = EncodeUtils.toJsonEncodeBytes(params); - if (result != null && result.length > 0){ - DelegationValue delegationValue = new DelegationValue(); - amino.decodeWithLengthPrefix(result, delegationValue); - return convert(delegationValue, delegationKey); + byte[] response = queryWithData("\"custom/stake/delegation\"", paramsBytes); + if (!ByteUtil.isEmpty(response)){ + DelegationResponse delegationResponse = EncodeUtils.getObjectMapper().readValue(response, DelegationResponse.class); + return convert(delegationResponse); } return null; } public List querySideChainDelegations(String sideChainId, String delegatorAddress) throws IOException { - byte[] storePrefix = getSideChainStorePrefixKey(sideChainId); - byte[] key = ByteUtil.appendBytesArray(storePrefix, getDelegationsKey(Crypto.decodeAddress(delegatorAddress))); - List kvPairs = queryStoreSubspaceKVPairs(stakeStoreName, key); + QueryDelegatorParams params = new QueryDelegatorParams(); + params.setSideChainId(sideChainId); + params.setDelegatorAddr(delegatorAddress); - List delegations = new ArrayList<>(); - for (common.Types.KVPair kvPair : kvPairs) { - DelegationValue value = new DelegationValue(); - amino.decodeWithLengthPrefix(kvPair.getValue().toByteArray(), value); - delegations.add(convert(value, Arrays.copyOfRange(kvPair.getKey().toByteArray(), storePrefix.length, kvPair.getKey().toByteArray().length))); - } + byte[] paramsBytes = EncodeUtils.toJsonEncodeBytes(params); + byte[] response = queryWithData("\"custom/stake/delegatorDelegations\"", paramsBytes); - return delegations; - } + List results = new ArrayList<>(); - private SideChainDelegation convert(DelegationValue delegationValue, byte[] key){ - if (key.length - 1 != addressLength * 2){ - throw new IllegalArgumentException("unexpected address length for this (address, validator) pair"); + if (!ByteUtil.isEmpty(response)){ + String a = new String(response); + List delegations = EncodeUtils.getObjectMapper().readValue(response, new TypeReference>(){}); + for (DelegationResponse delegation : delegations) { + results.add(convert(delegation)); + } } - byte[] delAddress = new byte[addressLength]; - byte[] valAddress = new byte[addressLength]; - System.arraycopy(key, 1, delAddress, 0, addressLength); - System.arraycopy(key, addressLength, valAddress, 0, addressLength); + return results; + } + private SideChainDelegation convert(DelegationResponse delegationResponse){ SideChainDelegation sideChainDelegation = new SideChainDelegation(); - sideChainDelegation.setDelegatorAddress(Crypto.encodeAddress(hrp, delAddress)); - sideChainDelegation.setValidatorAddress(Crypto.encodeAddress(valHrp, valAddress)); - sideChainDelegation.setHeight(delegationValue.getHeight()); - if (delegationValue.getShares() != null) { - sideChainDelegation.setShares(delegationValue.getShares().getValue()); + if (delegationResponse.getDelegation() != null) { + Delegation delegation = new Delegation(); + delegation.setDelegatorAddress(delegationResponse.getDelegation().getDelegatorAddress()); + delegation.setValidatorAddress(delegationResponse.getDelegation().getValidatorAddress()); + delegation.setShares(delegationResponse.getDelegation().getShares()); + sideChainDelegation.setDelegation(delegation); + } + if (delegationResponse.getBalance() != null){ + sideChainDelegation.setBalance(convert(delegationResponse.getBalance())); } return sideChainDelegation; diff --git a/src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegate.java b/src/main/java/com/binance/dex/api/client/impl/node/NodeTx.java similarity index 98% rename from src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegate.java rename to src/main/java/com/binance/dex/api/client/impl/node/NodeTx.java index a96d11a..3daa362 100644 --- a/src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegate.java +++ b/src/main/java/com/binance/dex/api/client/impl/node/NodeTx.java @@ -21,7 +21,7 @@ /** * @author Fitz.Lu **/ -class NodeTxDelegate { +class NodeTx { protected final BinanceDexNodeApi binanceDexNodeApi; @@ -29,7 +29,7 @@ class NodeTxDelegate { protected final String valHrp; - NodeTxDelegate(BinanceDexNodeApi binanceDexNodeApi, String hrp, String valHrp){ + NodeTx(BinanceDexNodeApi binanceDexNodeApi, String hrp, String valHrp){ this.binanceDexNodeApi = binanceDexNodeApi; this.hrp = hrp; this.valHrp = valHrp; diff --git a/src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegateBridge.java b/src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegateBridge.java index 6103f7a..d75748f 100644 --- a/src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegateBridge.java +++ b/src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegateBridge.java @@ -19,7 +19,7 @@ /** * @author Fitz.Lu **/ -public class NodeTxDelegateBridge extends NodeTxDelegate { +public class NodeTxDelegateBridge extends NodeTx { public NodeTxDelegateBridge(BinanceDexNodeApi binanceDexNodeApi, String hrp, String valHrp) { super(binanceDexNodeApi, hrp, valHrp); diff --git a/src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegateSideChainStaking.java b/src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegateSideChainStaking.java index ea5e80b..651080a 100644 --- a/src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegateSideChainStaking.java +++ b/src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegateSideChainStaking.java @@ -24,7 +24,7 @@ /** * @author Fitz.Lu **/ -public class NodeTxDelegateSideChainStaking extends NodeTxDelegate { +public class NodeTxDelegateSideChainStaking extends NodeTx { public NodeTxDelegateSideChainStaking(BinanceDexNodeApi binanceDexNodeApi, String hrp, String valHrp) { super(binanceDexNodeApi, hrp, valHrp); diff --git a/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java b/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java index 1c5b060..aa854c7 100644 --- a/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java +++ b/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java @@ -3,11 +3,7 @@ import com.binance.dex.api.client.BinanceDexEnvironment; import com.binance.dex.api.client.TransactionConverter; import com.binance.dex.api.client.Wallet; -import com.binance.dex.api.client.domain.bridge.TransferIn; -import com.binance.dex.api.client.domain.bridge.TransferOut; import com.binance.dex.api.client.domain.broadcast.Transaction; -import com.binance.dex.api.client.domain.broadcast.TransactionOption; -import com.binance.dex.api.client.domain.oracle.ClaimMsg; import com.binance.dex.api.client.domain.stake.Commission; import com.binance.dex.api.client.domain.stake.Description; import com.binance.dex.api.client.domain.stake.sidechain.*; @@ -53,7 +49,7 @@ public void testClaim() throws IOException { message.setValidatorAddress(Bech32AddressValue.fromBech32String("bva1337r5pk3r6kvs4a8kc3u5yhdjc79c5lg78343t")); byte[] data = amino.encode(message, MessageType.Claim.getTypePrefixBytes(), false); Transaction transaction = transactionConverter.convert(data); - System.out.println(transaction.getRealTx()); + Assert.assertNotNull(transaction.getRealTx()); } @Test @@ -65,7 +61,7 @@ public void testTransferOut() throws IOException { message.setToAddress(EthAddressValue.from("0xd1B22dCC24C55f4d728E7aaA5c9b5a22e1512C08")); byte[] data = amino.encode(message, MessageType.TransferOut.getTypePrefixBytes(), false); Transaction transaction = transactionConverter.convert(data); - System.out.println(transaction.getRealTx()); + Assert.assertNotNull(transaction.getRealTx()); } @Test @@ -79,7 +75,7 @@ public void testBind() throws IOException { message.setSymbol("BNB"); byte[] data = amino.encode(message, MessageType.Bind.getTypePrefixBytes(), false); Transaction transaction = transactionConverter.convert(data); - System.out.println(transaction.getRealTx()); + Assert.assertNotNull(transaction.getRealTx()); } @Test @@ -126,7 +122,7 @@ public void testCreateSideChainValidator() throws IOException { byte[] msg = amino.encode(convert(createSideChainValidator), MessageType.CreateSideChainValidator.getTypePrefixBytes(), false); Transaction tx = transactionConverter.convert(msg); - System.out.println(tx.getRealTx()); + Assert.assertNotNull(tx.getRealTx()); } @Test @@ -152,7 +148,7 @@ public void testDecodeEditSideChainValidator() throws IOException { byte[] msg = amino.encode(convert(editSideChainValidator), MessageType.EditSideChainValidator.getTypePrefixBytes(), false); Transaction tx = transactionConverter.convert(msg); - System.out.println(tx.getRealTx()); + Assert.assertNotNull(tx.getRealTx()); } @Test @@ -175,7 +171,7 @@ public void testDecodeSideChainDelegate() throws IOException { byte[] msg = amino.encode(convert(sideChainDelegate), MessageType.SideChainDelegate.getTypePrefixBytes(), false); Transaction tx = transactionConverter.convert(msg); - System.out.println(tx.getRealTx()); + Assert.assertNotNull(tx.getRealTx()); } @Test @@ -200,7 +196,7 @@ public void testDecodeSideChainRedelegate() throws IOException { byte[] msg = amino.encode(convert(redelegate), MessageType.SideChainRedelegate.getTypePrefixBytes(), false); Transaction tx = transactionConverter.convert(msg); - System.out.println(tx.getRealTx()); + Assert.assertNotNull(tx.getRealTx()); } @Test @@ -222,7 +218,7 @@ public void testDecodeSideChainUnBond() throws IOException { byte[] msg = amino.encode(convert(sideChainUndelegate), MessageType.SideChainUndelegate.getTypePrefixBytes(), false); Transaction tx = transactionConverter.convert(msg); - System.out.println(tx.getRealTx()); + Assert.assertNotNull(tx.getRealTx()); } EditSideChainValidatorMessage convert(EditSideChainValidator editSideChainValidator){ diff --git a/src/test/java/com/binance/dex/api/client/examples/BridgeNodeExample.java b/src/test/java/com/binance/dex/api/client/examples/BridgeNodeExample.java index b2967d2..d9c4377 100644 --- a/src/test/java/com/binance/dex/api/client/examples/BridgeNodeExample.java +++ b/src/test/java/com/binance/dex/api/client/examples/BridgeNodeExample.java @@ -12,6 +12,7 @@ import com.binance.dex.api.client.encoding.message.bridge.BindStatus; import com.binance.dex.api.client.encoding.message.bridge.ClaimTypes; import com.binance.dex.api.client.encoding.message.bridge.RefundReason; +import org.junit.Assert; import org.junit.Before; import org.junit.Test; @@ -26,7 +27,7 @@ public class BridgeNodeExample { private BinanceDexApiNodeClient nodeClient = null; - private final Wallet wallet = new Wallet("66d08fc209b31090ea21a8cf9a6e2680b008e2b905b2358ae31e0f42b140de99", BinanceDexEnvironment.TEST_NET); + private final Wallet wallet = new Wallet("bce1c934173e84cb4a0abf06b371f7568d3c4686da8f3ea7e1e8d230ae681920", BinanceDexEnvironment.TEST_NET); @Before public void setup() { @@ -34,7 +35,7 @@ public void setup() { } @Test - public void transferIn(){ + public void transferIn() throws IOException, NoSuchAlgorithmException { TransferIn transferIn = new TransferIn(); transferIn.setContractAddress("0xd1B22dCC24C55f4d728E7aaA5c9b5a22e1512C08"); @@ -60,40 +61,24 @@ public void transferIn(){ long sequence = nodeClient.getCurrentSequence(ClaimTypes.ClaimTypeTransferIn); - try { - List results = nodeClient.transferIn(sequence, transferIn, wallet, options, true); - if (results != null){ - for (TransactionMetadata result : results) { - System.out.println(result.toString()); - } - } - } catch (IOException | NoSuchAlgorithmException e) { - e.printStackTrace(); - } + List results = nodeClient.transferIn(sequence, transferIn, wallet, options, true); + Assert.assertEquals(1, results.size()); } @Test - public void transferOut(){ + public void transferOut() throws IOException, NoSuchAlgorithmException { String toAddress = "0x9fB29AAc15b9A4B7F17c3385939b007540f4d791"; Token token = new Token("BNB", 100000L); long expireTime = System.currentTimeMillis() + 1000 * 60 * 60 * 24 * 3; TransactionOption options = new TransactionOption("", 0, null); - try { - List results = nodeClient.transferOut(toAddress, token, expireTime / 1000, wallet, options, true); - if (results != null){ - for (TransactionMetadata result : results) { - System.out.println(result.toString()); - } - } - } catch (IOException | NoSuchAlgorithmException e) { - e.printStackTrace(); - } + List results = nodeClient.transferOut(toAddress, token, expireTime / 1000, wallet, options, true); + Assert.assertEquals(1, results.size()); } @Test - public void bind(){ + public void bind() throws IOException, NoSuchAlgorithmException { String symbol = "BNB"; long amount = 1000000L; String contractAddress = "0xd1B22dCC24C55f4d728E7aaA5c9b5a22e1512C08"; @@ -102,20 +87,12 @@ public void bind(){ TransactionOption options = new TransactionOption("", 0, null); - try { - List results = nodeClient.bind(symbol, amount, contractAddress, contractDecimal, expireTime / 1000, wallet, options, true); - if (results != null){ - for (TransactionMetadata result : results) { - System.out.println(result.toString()); - } - } - } catch (IOException | NoSuchAlgorithmException e) { - e.printStackTrace(); - } + List results = nodeClient.bind(symbol, amount, contractAddress, contractDecimal, expireTime / 1000, wallet, options, true); + Assert.assertEquals(1, results.size()); } @Test - public void updateTransferOut(){ + public void updateTransferOut() throws IOException, NoSuchAlgorithmException { long sequence = nodeClient.getCurrentSequence(ClaimTypes.ClaimTypeUpdateTransferOut); String refundAddress = wallet.getAddress(); Token amount = new Token("BNB", 100000L); @@ -123,20 +100,12 @@ public void updateTransferOut(){ TransactionOption options = new TransactionOption("", 0, null); - try { - List results = nodeClient.updateTransferOut(sequence, refundAddress, amount, refundReason, wallet, options, true); - if (results != null){ - for (TransactionMetadata result : results) { - System.out.println(result.toString()); - } - } - } catch (IOException | NoSuchAlgorithmException e) { - e.printStackTrace(); - } + List results = nodeClient.updateTransferOut(sequence, refundAddress, amount, refundReason, wallet, options, true); + Assert.assertEquals(1, results.size()); } @Test - public void updateBind(){ + public void updateBind() throws IOException, NoSuchAlgorithmException { long sequence = nodeClient.getCurrentSequence(ClaimTypes.ClaimTypeUpdateBind); String symbol = "BNB"; String contractAddress = "0xd1B22dCC24C55f4d728E7aaA5c9b5a22e1512C08"; @@ -144,47 +113,29 @@ public void updateBind(){ TransactionOption options = new TransactionOption("", 0, null); - try { - List results = nodeClient.updateBind(sequence, symbol, contractAddress, status, wallet, options, true); - if (results != null){ - for (TransactionMetadata result : results) { - System.out.println(result.toString()); - } - } - } catch (IOException | NoSuchAlgorithmException e) { - e.printStackTrace(); - } + List results = nodeClient.updateBind(sequence, symbol, contractAddress, status, wallet, options, true); + Assert.assertEquals(1, results.size()); } @Test - public void claim(){ + public void claim() throws IOException, NoSuchAlgorithmException { TransactionOption options = new TransactionOption("", 0, null); - try { - List results = nodeClient.claim(ClaimTypes.ClaimTypeUpdateBind, "claim message", 1, wallet, options, true); - if (results != null){ - for (TransactionMetadata result : results) { - System.out.println(result.toString()); - } - } - } catch (IOException | NoSuchAlgorithmException e) { - e.printStackTrace(); - } + List results = nodeClient.claim(ClaimTypes.ClaimTypeUpdateBind, "claim message", 1, wallet, options, true); + Assert.assertEquals(1, results.size()); } @Test - public void getProphecy(){ - try { - Prophecy prophecy = nodeClient.getProphecy(ClaimTypes.ClaimTypeTransferIn, 1); - System.out.println(prophecy.toString()); - } catch (NullPointerException | IOException e) { - e.printStackTrace(); + public void getProphecy() throws IOException { + Prophecy prophecy = nodeClient.getProphecy(ClaimTypes.ClaimTypeTransferIn, 1); + if (prophecy != null){ + Assert.assertNotNull(prophecy.getClaimValidators()); } } @Test public void getCurrentSequence(){ long sequence = nodeClient.getCurrentSequence(ClaimTypes.ClaimTypeTransferIn); - System.out.println(sequence); + Assert.assertTrue(sequence >= 0); } } diff --git a/src/test/java/com/binance/dex/api/client/examples/SideChainStakingNodeExample.java b/src/test/java/com/binance/dex/api/client/examples/SideChainStakingNodeExample.java index a56ec2c..9c70f31 100644 --- a/src/test/java/com/binance/dex/api/client/examples/SideChainStakingNodeExample.java +++ b/src/test/java/com/binance/dex/api/client/examples/SideChainStakingNodeExample.java @@ -11,6 +11,7 @@ import com.binance.dex.api.client.domain.stake.Pool; import com.binance.dex.api.client.domain.stake.sidechain.*; import com.binance.dex.api.client.encoding.message.*; +import com.binance.dex.api.client.encoding.message.sidechain.SideChainIds; import org.junit.Assert; import org.junit.Before; import org.junit.Test; @@ -42,7 +43,7 @@ public void setup() { } @Test - public void testCreateSideChainValidator(){ + public void testCreateSideChainValidator() throws IOException, NoSuchAlgorithmException { CreateSideChainValidator createSideChainValidator = new CreateSideChainValidator(); //create and set description @@ -72,7 +73,7 @@ public void testCreateSideChainValidator(){ createSideChainValidator.setDelegation(delegationToken); //set side-chain id - createSideChainValidator.setSideChainId("bsc"); + createSideChainValidator.setSideChainId(SideChainIds.BSC); //set side-chain validator cons address createSideChainValidator.setSideConsAddr("0x9fB29AAc15b9A4B7F17c3385939b007540f4d791"); @@ -82,18 +83,12 @@ public void testCreateSideChainValidator(){ TransactionOption options = new TransactionOption("", 0, null); - try { - List transactionMetadatas = nodeClient.createSideChainValidator(createSideChainValidator, wallet, options, true); - for (TransactionMetadata transactionMetadata : transactionMetadatas) { - System.out.println(transactionMetadata.toString()); - } - } catch (IOException | NoSuchAlgorithmException e) { - e.printStackTrace(); - } + List transactionMetadatas = nodeClient.createSideChainValidator(createSideChainValidator, wallet, options, true); + Assert.assertEquals(1, transactionMetadatas.size()); } @Test - public void testEditSideChainValidator(){ + public void testEditSideChainValidator() throws IOException, NoSuchAlgorithmException { EditSideChainValidator editSideChainValidator = new EditSideChainValidator(); //set new description if needed @@ -107,20 +102,14 @@ public void testEditSideChainValidator(){ //set new fee address if needed editSideChainValidator.setSideFeeAddr("0xd1B22dCC24C55f4d728E7aaA5c9b5a22e1512C08"); - editSideChainValidator.setSideChainId("bsc"); + editSideChainValidator.setSideChainId(SideChainIds.BSC); - try { - List transactionMetadatas = nodeClient.editSideChainValidator(editSideChainValidator, wallet, createTransactionOptionForTest(), true); - for (TransactionMetadata transactionMetadata : transactionMetadatas) { - consolePrintln(transactionMetadata); - } - }catch (IOException | NoSuchAlgorithmException e){ - e.printStackTrace(); - } + List transactionMetadatas = nodeClient.editSideChainValidator(editSideChainValidator, wallet, createTransactionOptionForTest(), true); + Assert.assertEquals(1, transactionMetadatas.size()); } @Test - public void testSideChainDelegate(){ + public void testSideChainDelegate() throws IOException, NoSuchAlgorithmException { SideChainDelegate sideChainDelegate = new SideChainDelegate(); //set delegate token @@ -134,20 +123,14 @@ public void testSideChainDelegate(){ sideChainDelegate.setValidatorAddress(roseValidator); //set side-chain id - sideChainDelegate.setSideChainId("bsc"); - - try { - List transactionMetadatas = nodeClient.sideChainDelegate(sideChainDelegate, wallet, createTransactionOptionForTest(), true); - for (TransactionMetadata transactionMetadata : transactionMetadatas) { - consolePrintln(transactionMetadata); - } - }catch (IOException | NoSuchAlgorithmException e){ - e.printStackTrace(); - } + sideChainDelegate.setSideChainId(SideChainIds.BSC); + + List transactionMetadatas = nodeClient.sideChainDelegate(sideChainDelegate, wallet, createTransactionOptionForTest(), true); + Assert.assertEquals(1, transactionMetadatas.size()); } @Test - public void testSideChainRedelegate(){ + public void testSideChainRedelegate() throws IOException, NoSuchAlgorithmException { SideChainRedelegate redelegate = new SideChainRedelegate(); //set redelegate amount @@ -163,18 +146,14 @@ public void testSideChainRedelegate(){ redelegate.setDstValidatorAddress(roseValidator); //set side-chain id - redelegate.setSideChainId("bsc"); + redelegate.setSideChainId(SideChainIds.BSC); - try { - List transactionMetadatas = nodeClient.sideChainRedelagate(redelegate, wallet, createTransactionOptionForTest(), true); - consolePrintln(transactionMetadatas.get(0)); - }catch (IOException | NoSuchAlgorithmException e){ - e.printStackTrace(); - } + List transactionMetadatas = nodeClient.sideChainRedelagate(redelegate, wallet, createTransactionOptionForTest(), true); + Assert.assertEquals(1, transactionMetadatas.size()); } @Test - public void testSideChainUnbond(){ + public void testSideChainUnbond() throws IOException, NoSuchAlgorithmException { SideChainUnBond sideChainUndelegate = new SideChainUnBond(); //set unbond amount @@ -187,105 +166,93 @@ public void testSideChainUnbond(){ sideChainUndelegate.setValidatorAddress(jackValidator); //set side-chain id - sideChainUndelegate.setSideChainId("bsc"); + sideChainUndelegate.setSideChainId(SideChainIds.BSC); - try { - List transactionMetadatas = nodeClient.sideChainUnbond(sideChainUndelegate, wallet, createTransactionOptionForTest(), true); - consolePrintln(transactionMetadatas.get(0)); - }catch (IOException | NoSuchAlgorithmException e){ - e.printStackTrace(); - } + List transactionMetadatas = nodeClient.sideChainUnbond(sideChainUndelegate, wallet, createTransactionOptionForTest(), true); + Assert.assertEquals(1, transactionMetadatas.size()); } @Test public void testGetSideChainValidator() throws IOException { - SideChainValidator validator = nodeClient.getSideChainValidator("bsc", jackValidator); - Assert.assertNotNull(validator); - consolePrintln(validator); + SideChainValidator validator = nodeClient.getSideChainValidator(SideChainIds.BSC, jackValidator); + if (validator != null){ + Assert.assertNotNull(validator.getOperatorAddr()); + } } @Test public void testGetSideChainTopValidators() throws IOException { - List validators = nodeClient.getSideChainTopValidators("bsc", 5); - for (SideChainValidator validator : validators) { - consolePrintln(validator); - } + List validators = nodeClient.getSideChainTopValidators(SideChainIds.BSC, 5); + Assert.assertNotNull(validators); } @Test public void testGetSideChainDelegation() throws IOException { - SideChainDelegation delegation = nodeClient.getSideChainDelegation("bsc", wallet.getAddress(), roseValidator); + SideChainDelegation delegation = nodeClient.getSideChainDelegation(SideChainIds.BSC, wallet.getAddress(), roseValidator); if (delegation != null) { - consolePrintln(delegation); + Assert.assertNotNull(delegation.getDelegation()); + Assert.assertNotNull(delegation.getBalance()); } } @Test public void testGetSideChainDelegations() throws IOException { - List delegations = nodeClient.getSideChainDelegations("bsc", wallet.getAddress()); - for (SideChainDelegation delegation : delegations) { - consolePrintln(delegation); - } + List delegations = nodeClient.getSideChainDelegations(SideChainIds.BSC, wallet.getAddress()); + Assert.assertNotNull(delegations); } @Test public void getSideChainRedelegation() throws IOException { - SideChainRedelegation redelegation = nodeClient.getSideChainRedelegation("bsc", wallet.getAddress(), jackValidator, roseValidator); + SideChainRedelegation redelegation = nodeClient.getSideChainRedelegation(SideChainIds.BSC, wallet.getAddress(), jackValidator, roseValidator); if (redelegation != null) { - consolePrintln(redelegation); + Assert.assertNotNull(redelegation.getDelegatorAddress()); } } @Test public void getSideChainRedelegations() throws IOException { - List redelegations = nodeClient.getSideChainRedelegations("bsc", wallet.getAddress()); - for (SideChainRedelegation redelegation : redelegations) { - consolePrintln(redelegation); - } + List redelegations = nodeClient.getSideChainRedelegations(SideChainIds.BSC, wallet.getAddress()); + Assert.assertNotNull(redelegations); } @Test public void getSideChainUnBondingDelegation() throws IOException { - UnBondingDelegation unBondingDelegation = nodeClient.getSideChainUnBondingDelegation("bsc", wallet.getAddress(), jackValidator); + UnBondingDelegation unBondingDelegation = nodeClient.getSideChainUnBondingDelegation(SideChainIds.BSC, wallet.getAddress(), jackValidator); if (unBondingDelegation != null) { - consolePrintln(unBondingDelegation); + Assert.assertNotNull(unBondingDelegation.getDelegatorAddress()); } } @Test public void getSideChainUnBondingDelegations() throws IOException { - List unBondingDelegations = nodeClient.getSideChainUnBondingDelegations("bsc", wallet.getAddress()); - for (UnBondingDelegation unBondingDelegation : unBondingDelegations) { - consolePrintln(unBondingDelegation); - } + List unBondingDelegations = nodeClient.getSideChainUnBondingDelegations(SideChainIds.BSC, wallet.getAddress()); + Assert.assertNotNull(unBondingDelegations); } @Test public void testGetSideChainUnBondingDelegationsByValidator() throws IOException { - List unBondingDelegations = nodeClient.getSideChainUnBondingDelegationsByValidator("bsc", jackValidator); - for (UnBondingDelegation unBondingDelegation : unBondingDelegations) { - consolePrintln(unBondingDelegation); - } + List unBondingDelegations = nodeClient.getSideChainUnBondingDelegationsByValidator(SideChainIds.BSC, jackValidator); + Assert.assertNotNull(unBondingDelegations); } @Test public void testGetSideChainRedelegationsByValidator() throws IOException { - List redelegations = nodeClient.getSideChainRedelegationsByValidator("bsc", jackValidator); - for (SideChainRedelegation redelegation : redelegations) { - consolePrintln(redelegation); - } + List redelegations = nodeClient.getSideChainRedelegationsByValidator(SideChainIds.BSC, jackValidator); + Assert.assertNotNull(redelegations); } @Test public void testGetSideChainPool() throws IOException { - Pool pool = nodeClient.getSideChainPool("bsc"); - consolePrintln(pool); + Pool pool = nodeClient.getSideChainPool(SideChainIds.BSC); + if (pool != null){ + Assert.assertTrue(pool.getBondedTokens() >= 0L); + } } @Test public void testGetSideChainValidatorsCount() throws IOException { - long count = nodeClient.getAllSideChainValidatorsCount("bsc", false); - consolePrintln(count); + long count = nodeClient.getAllSideChainValidatorsCount(SideChainIds.BSC, false); + Assert.assertTrue(count >= 0); } /** From 46e30f639e1ddb55486ffb556bbd9868eb083564 Mon Sep 17 00:00:00 2001 From: FitzLu Date: Wed, 13 May 2020 19:57:30 +0800 Subject: [PATCH 06/52] change sidechain id --- .../message/sidechain/SideChainIds.java | 2 +- .../examples/SideChainStakingNodeExample.java | 34 +++++++++---------- 2 files changed, 18 insertions(+), 18 deletions(-) diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/SideChainIds.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/SideChainIds.java index 2581a25..eef2139 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/SideChainIds.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/SideChainIds.java @@ -5,6 +5,6 @@ **/ public class SideChainIds { - public static final String BSC = "bsc"; + public static final String RIALTO = "rialto"; } diff --git a/src/test/java/com/binance/dex/api/client/examples/SideChainStakingNodeExample.java b/src/test/java/com/binance/dex/api/client/examples/SideChainStakingNodeExample.java index 9c70f31..d9b924a 100644 --- a/src/test/java/com/binance/dex/api/client/examples/SideChainStakingNodeExample.java +++ b/src/test/java/com/binance/dex/api/client/examples/SideChainStakingNodeExample.java @@ -73,7 +73,7 @@ public void testCreateSideChainValidator() throws IOException, NoSuchAlgorithmEx createSideChainValidator.setDelegation(delegationToken); //set side-chain id - createSideChainValidator.setSideChainId(SideChainIds.BSC); + createSideChainValidator.setSideChainId(SideChainIds.RIALTO); //set side-chain validator cons address createSideChainValidator.setSideConsAddr("0x9fB29AAc15b9A4B7F17c3385939b007540f4d791"); @@ -102,7 +102,7 @@ public void testEditSideChainValidator() throws IOException, NoSuchAlgorithmExce //set new fee address if needed editSideChainValidator.setSideFeeAddr("0xd1B22dCC24C55f4d728E7aaA5c9b5a22e1512C08"); - editSideChainValidator.setSideChainId(SideChainIds.BSC); + editSideChainValidator.setSideChainId(SideChainIds.RIALTO); List transactionMetadatas = nodeClient.editSideChainValidator(editSideChainValidator, wallet, createTransactionOptionForTest(), true); Assert.assertEquals(1, transactionMetadatas.size()); @@ -123,7 +123,7 @@ public void testSideChainDelegate() throws IOException, NoSuchAlgorithmException sideChainDelegate.setValidatorAddress(roseValidator); //set side-chain id - sideChainDelegate.setSideChainId(SideChainIds.BSC); + sideChainDelegate.setSideChainId(SideChainIds.RIALTO); List transactionMetadatas = nodeClient.sideChainDelegate(sideChainDelegate, wallet, createTransactionOptionForTest(), true); Assert.assertEquals(1, transactionMetadatas.size()); @@ -146,7 +146,7 @@ public void testSideChainRedelegate() throws IOException, NoSuchAlgorithmExcepti redelegate.setDstValidatorAddress(roseValidator); //set side-chain id - redelegate.setSideChainId(SideChainIds.BSC); + redelegate.setSideChainId(SideChainIds.RIALTO); List transactionMetadatas = nodeClient.sideChainRedelagate(redelegate, wallet, createTransactionOptionForTest(), true); Assert.assertEquals(1, transactionMetadatas.size()); @@ -166,7 +166,7 @@ public void testSideChainUnbond() throws IOException, NoSuchAlgorithmException { sideChainUndelegate.setValidatorAddress(jackValidator); //set side-chain id - sideChainUndelegate.setSideChainId(SideChainIds.BSC); + sideChainUndelegate.setSideChainId(SideChainIds.RIALTO); List transactionMetadatas = nodeClient.sideChainUnbond(sideChainUndelegate, wallet, createTransactionOptionForTest(), true); Assert.assertEquals(1, transactionMetadatas.size()); @@ -174,7 +174,7 @@ public void testSideChainUnbond() throws IOException, NoSuchAlgorithmException { @Test public void testGetSideChainValidator() throws IOException { - SideChainValidator validator = nodeClient.getSideChainValidator(SideChainIds.BSC, jackValidator); + SideChainValidator validator = nodeClient.getSideChainValidator(SideChainIds.RIALTO, jackValidator); if (validator != null){ Assert.assertNotNull(validator.getOperatorAddr()); } @@ -182,13 +182,13 @@ public void testGetSideChainValidator() throws IOException { @Test public void testGetSideChainTopValidators() throws IOException { - List validators = nodeClient.getSideChainTopValidators(SideChainIds.BSC, 5); + List validators = nodeClient.getSideChainTopValidators(SideChainIds.RIALTO, 5); Assert.assertNotNull(validators); } @Test public void testGetSideChainDelegation() throws IOException { - SideChainDelegation delegation = nodeClient.getSideChainDelegation(SideChainIds.BSC, wallet.getAddress(), roseValidator); + SideChainDelegation delegation = nodeClient.getSideChainDelegation(SideChainIds.RIALTO, wallet.getAddress(), roseValidator); if (delegation != null) { Assert.assertNotNull(delegation.getDelegation()); Assert.assertNotNull(delegation.getBalance()); @@ -197,13 +197,13 @@ public void testGetSideChainDelegation() throws IOException { @Test public void testGetSideChainDelegations() throws IOException { - List delegations = nodeClient.getSideChainDelegations(SideChainIds.BSC, wallet.getAddress()); + List delegations = nodeClient.getSideChainDelegations(SideChainIds.RIALTO, wallet.getAddress()); Assert.assertNotNull(delegations); } @Test public void getSideChainRedelegation() throws IOException { - SideChainRedelegation redelegation = nodeClient.getSideChainRedelegation(SideChainIds.BSC, wallet.getAddress(), jackValidator, roseValidator); + SideChainRedelegation redelegation = nodeClient.getSideChainRedelegation(SideChainIds.RIALTO, wallet.getAddress(), jackValidator, roseValidator); if (redelegation != null) { Assert.assertNotNull(redelegation.getDelegatorAddress()); } @@ -211,13 +211,13 @@ public void getSideChainRedelegation() throws IOException { @Test public void getSideChainRedelegations() throws IOException { - List redelegations = nodeClient.getSideChainRedelegations(SideChainIds.BSC, wallet.getAddress()); + List redelegations = nodeClient.getSideChainRedelegations(SideChainIds.RIALTO, wallet.getAddress()); Assert.assertNotNull(redelegations); } @Test public void getSideChainUnBondingDelegation() throws IOException { - UnBondingDelegation unBondingDelegation = nodeClient.getSideChainUnBondingDelegation(SideChainIds.BSC, wallet.getAddress(), jackValidator); + UnBondingDelegation unBondingDelegation = nodeClient.getSideChainUnBondingDelegation(SideChainIds.RIALTO, wallet.getAddress(), jackValidator); if (unBondingDelegation != null) { Assert.assertNotNull(unBondingDelegation.getDelegatorAddress()); } @@ -225,25 +225,25 @@ public void getSideChainUnBondingDelegation() throws IOException { @Test public void getSideChainUnBondingDelegations() throws IOException { - List unBondingDelegations = nodeClient.getSideChainUnBondingDelegations(SideChainIds.BSC, wallet.getAddress()); + List unBondingDelegations = nodeClient.getSideChainUnBondingDelegations(SideChainIds.RIALTO, wallet.getAddress()); Assert.assertNotNull(unBondingDelegations); } @Test public void testGetSideChainUnBondingDelegationsByValidator() throws IOException { - List unBondingDelegations = nodeClient.getSideChainUnBondingDelegationsByValidator(SideChainIds.BSC, jackValidator); + List unBondingDelegations = nodeClient.getSideChainUnBondingDelegationsByValidator(SideChainIds.RIALTO, jackValidator); Assert.assertNotNull(unBondingDelegations); } @Test public void testGetSideChainRedelegationsByValidator() throws IOException { - List redelegations = nodeClient.getSideChainRedelegationsByValidator(SideChainIds.BSC, jackValidator); + List redelegations = nodeClient.getSideChainRedelegationsByValidator(SideChainIds.RIALTO, jackValidator); Assert.assertNotNull(redelegations); } @Test public void testGetSideChainPool() throws IOException { - Pool pool = nodeClient.getSideChainPool(SideChainIds.BSC); + Pool pool = nodeClient.getSideChainPool(SideChainIds.RIALTO); if (pool != null){ Assert.assertTrue(pool.getBondedTokens() >= 0L); } @@ -251,7 +251,7 @@ public void testGetSideChainPool() throws IOException { @Test public void testGetSideChainValidatorsCount() throws IOException { - long count = nodeClient.getAllSideChainValidatorsCount(SideChainIds.BSC, false); + long count = nodeClient.getAllSideChainValidatorsCount(SideChainIds.RIALTO, false); Assert.assertTrue(count >= 0); } From 671c2de689270f666b7dd45193b0dd792a64861c Mon Sep 17 00:00:00 2001 From: FitzLu Date: Fri, 22 May 2020 15:25:48 +0800 Subject: [PATCH 07/52] update readme --- README.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 0dbb9c8..cb8f17f 100644 --- a/README.md +++ b/README.md @@ -7,6 +7,8 @@ The Binance Chain Java SDK works as a lightweight Java library for interacting w * **[client](https://github.com/binance-chain/java-sdk/tree/master/src/main/java/com/binance/dex/api/client/impl)** - implementations of API rest client, supporting synchronous and asynchronous access to Binance Chain's REST APIs. * **[wallet](https://github.com/binance-chain/java-sdk/blob/master/src/main/java/com/binance/dex/api/client/Wallet.java)** - management of accounts, including seed and encrypted mnemonic generation. +## Disclaimer +**This branch is under active development, all subject to potential future change without notification and not ready for production use. The code and security audit have not been fully completed and not ready for any bug bounty.** # Installation @@ -17,7 +19,7 @@ The Binance Chain Java SDK works as a lightweight Java library for interacting w com.binance.dex.api binance-dex-api-client - 1.0.4 + 1.1.0 ``` # Protobuf From 0f17a4e5ab546b9238bbe8fd934f114a5348a73e Mon Sep 17 00:00:00 2001 From: George <61674316+forcodedancing@users.noreply.github.com> Date: Mon, 1 Jun 2020 17:07:50 +0800 Subject: [PATCH 08/52] Support Mini Token (#80) * add mini token features --- CHANGELOG.md | 5 + pom.xml | 2 +- .../binance/dex/api/client/BinanceDexApi.java | 40 ++++++ .../api/client/BinanceDexApiNodeClient.java | 67 +++++++++ .../api/client/BinanceDexApiRestClient.java | 26 ++++ .../dex/api/client/TransactionConverter.java | 134 ++++++++++++++---- .../dex/api/client/domain/MiniToken.java | 109 ++++++++++++++ .../binance/dex/api/client/domain/Token.java | 9 ++ .../domain/broadcast/MiniTokenIssue.java | 26 ++++ .../domain/broadcast/MiniTokenListing.java | 51 +++++++ .../domain/broadcast/MiniTokenSetURI.java | 41 ++++++ .../domain/broadcast/TinyTokenIssue.java | 26 ++++ .../api/client/domain/broadcast/TxType.java | 6 +- .../client/encoding/message/MessageType.java | 11 +- .../impl/BinanceDexApiNodeClientImpl.java | 30 ++++ .../impl/BinanceDexApiRestClientImpl.java | 85 +++++++++++ src/main/proto/dex.proto | 46 ++++++ .../encoding/message/TestRestClient.java | 52 ++++++- .../examples/BinanceDexWSApiExample.java | 4 +- .../examples/LocalEnvironmentExample.java | 53 +++++++ .../client/examples/NodeClientExample.java | 7 + 21 files changed, 798 insertions(+), 32 deletions(-) create mode 100644 CHANGELOG.md create mode 100644 src/main/java/com/binance/dex/api/client/domain/MiniToken.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/broadcast/MiniTokenIssue.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/broadcast/MiniTokenListing.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/broadcast/MiniTokenSetURI.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/broadcast/TinyTokenIssue.java create mode 100644 src/test/java/com/binance/dex/api/client/examples/LocalEnvironmentExample.java diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..b694498 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,5 @@ +# Changelog +## 1.0.7 +CHAIN UPGRADE +* [\#110](https://github.com/binance-chain/java-sdk/pull/84) [RPC] [API] Add Pending match flag to Depth API response +* [\#115](https://github.com/binance-chain/java-sdk/pull/80) [RPC] [API] Support Mini Token \ No newline at end of file diff --git a/pom.xml b/pom.xml index fdbc174..d5616d3 100644 --- a/pom.xml +++ b/pom.xml @@ -5,7 +5,7 @@ com.binance.dex.api binance-dex-api-client - 1.0.6 + 1.0.7 2.6.0 diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexApi.java b/src/main/java/com/binance/dex/api/client/BinanceDexApi.java index c6f5324..15523b9 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexApi.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexApi.java @@ -85,4 +85,44 @@ Call getTransactions(@Query("address") String address, @Query(" @POST("api/v1/broadcast") Call> broadcast(@Query("sync") boolean sync, @Body RequestBody transaction); + + @GET("api/v1/mini/tokens") + Call> getMiniTokens(@Query("limit") Integer limit); + + @GET("api/v1/mini/markets") + Call> getMiniMarkets(@Query("limit") Integer limit); + + @GET("api/v1/mini/klines") + Call> getMiniCandlestickBars(@Query("symbol") String symbol, @Query("interval") String interval, + @Query("limit") Integer limit, @Query("startTime") Long startTime, + @Query("endTime") Long endTime); + + @GET("api/v1/mini/orders/open") + Call getMiniOpenOrders(@Query("address") String address, @Query("limit") Integer limit, + @Query("offset") Integer offset, @Query("symbol") String symbol, + @Query("total") Integer total); + + @GET("api/v1/mini/orders/closed") + Call getMiniClosedOrders(@Query("address") String address, @Query("end") Long end, + @Query("limit") Integer limit, @Query("offset") Integer offset, + @Query("side") Integer side, @Query("start") Long start, + @Query("status") List status, @Query("symbol") String symbol, + @Query("total") Integer total); + + @GET("api/v1/mini/orders/{id}") + Call getMiniOrder(@Path("id") String id); + + @GET("api/v1/mini/ticker/24hr") + Call> getMini24HrPriceStatistics(); + + @GET("api/v1/mini/ticker/24hr") + Call> getMini24HrPriceStatistics(@Query("symbol") String symbol); + + @GET("api/v1/mini/trades") + Call getMiniTrades(@Query("address") String address, + @Query("buyerOrderId") String buyerOrderId, @Query("end") Long end, + @Query("height") Long height, @Query("limit") Integer limit, + @Query("offset") Integer offset, @Query("quoteAsset") String quoteAsset, + @Query("sellerOrderId") String sellerOrderId, @Query("side") Integer side, + @Query("start") Long start, @Query("symbol") String symbol, @Query("total") Integer total); } diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java b/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java index 398b782..be20e33 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java @@ -32,6 +32,8 @@ public interface BinanceDexApiNodeClient extends BinanceDexApiRestClient { AtomicSwap getSwapByID(String swapID); + MiniToken getMiniTokenInfoBySymbol(String symbol); + @Override default Time getTime() { throw new UnsupportedOperationException(); @@ -132,6 +134,71 @@ default TransactionPage getTransactions(TransactionsRequest request) { throw new UnsupportedOperationException(); } + @Override + default List getMiniTokens(Integer limit) { + throw new UnsupportedOperationException(); + } + + @Override + default List getMiniMarkets(Integer limit) { + throw new UnsupportedOperationException(); + } + + @Override + default List getMiniCandleStickBars(String symbol, CandlestickInterval interval) { + throw new UnsupportedOperationException(); + } + + @Override + default List getMiniCandleStickBars(String symbol, CandlestickInterval interval, Integer limit, Long startTime, Long endTime) { + throw new UnsupportedOperationException(); + } + + @Override + default OrderList getMiniOpenOrders(String address) { + throw new UnsupportedOperationException(); + } + + @Override + default OrderList getMiniOpenOrders(OpenOrdersRequest request) { + throw new UnsupportedOperationException(); + } + + @Override + default OrderList getMiniClosedOrders(String address) { + throw new UnsupportedOperationException(); + } + + @Override + default OrderList getMiniClosedOrders(ClosedOrdersRequest request) { + throw new UnsupportedOperationException(); + } + + @Override + default Order getMiniOrder(String id) { + throw new UnsupportedOperationException(); + } + + @Override + default List getMini24HrPriceStatistics() { + throw new UnsupportedOperationException(); + } + + @Override + default List getMini24HrPriceStatistics(String symbol) { + throw new UnsupportedOperationException(); + } + + @Override + default TradePage getMiniTrades() { + throw new UnsupportedOperationException(); + } + + @Override + default TradePage getMiniTrades(TradesRequest request) { + throw new UnsupportedOperationException(); + } + @Override default List newOrder(NewOrder newOrder, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { throw new UnsupportedOperationException(); diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexApiRestClient.java b/src/main/java/com/binance/dex/api/client/BinanceDexApiRestClient.java index 17706e4..5f8203c 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexApiRestClient.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexApiRestClient.java @@ -60,6 +60,32 @@ public interface BinanceDexApiRestClient { TransactionPage getTransactions(TransactionsRequest request); + List getMiniTokens(Integer limit); + + List getMiniMarkets(Integer limit); + + List getMiniCandleStickBars(String symbol, CandlestickInterval interval); + + List getMiniCandleStickBars(String symbol, CandlestickInterval interval, Integer limit, Long startTime, Long endTime); + + OrderList getMiniOpenOrders(String address); + + OrderList getMiniOpenOrders(OpenOrdersRequest request); + + OrderList getMiniClosedOrders(String address); + + OrderList getMiniClosedOrders(ClosedOrdersRequest request); + + Order getMiniOrder(String id); + + List getMini24HrPriceStatistics(); + + List getMini24HrPriceStatistics(String symbol); + + TradePage getMiniTrades(); + + TradePage getMiniTrades(TradesRequest request); + List newOrder(NewOrder newOrder, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; diff --git a/src/main/java/com/binance/dex/api/client/TransactionConverter.java b/src/main/java/com/binance/dex/api/client/TransactionConverter.java index 960ed76..7e7d6a2 100644 --- a/src/main/java/com/binance/dex/api/client/TransactionConverter.java +++ b/src/main/java/com/binance/dex/api/client/TransactionConverter.java @@ -5,6 +5,8 @@ import com.binance.dex.api.client.domain.broadcast.Burn; import com.binance.dex.api.client.domain.broadcast.CancelOrder; import com.binance.dex.api.client.domain.broadcast.CreateValidator; +import com.binance.dex.api.client.domain.broadcast.MiniTokenIssue; +import com.binance.dex.api.client.domain.broadcast.MiniTokenSetURI; import com.binance.dex.api.client.domain.broadcast.RemoveValidator; import com.binance.dex.api.client.domain.broadcast.Deposit; import com.binance.dex.api.client.domain.broadcast.Issue; @@ -12,6 +14,7 @@ import com.binance.dex.api.client.domain.broadcast.NewOrder; import com.binance.dex.api.client.domain.broadcast.SetAccountFlag; import com.binance.dex.api.client.domain.broadcast.SubmitProposal; +import com.binance.dex.api.client.domain.broadcast.TinyTokenIssue; import com.binance.dex.api.client.domain.broadcast.TokenFreeze; import com.binance.dex.api.client.domain.broadcast.TokenUnfreeze; import com.binance.dex.api.client.domain.broadcast.Transaction; @@ -37,7 +40,7 @@ public class TransactionConverter { private String hrp; - public TransactionConverter(String hrp){ + public TransactionConverter(String hrp) { this.hrp = hrp; } @@ -64,7 +67,7 @@ public List convert(com.binance.dex.api.client.domain.jsonrpc.Block transaction.setResultData(Optional.ofNullable(txMessage.getTx_result()).map(TxResult::getData).orElse(null)); transaction.setSource(stdTx.getSource()); transaction.setSequence(stdSignature.getSequence()); - fillTagsAndEvents(txMessage.getTx_result(),transaction); + fillTagsAndEvents(txMessage.getTx_result(), transaction); return transaction; }).filter(Objects::nonNull).collect(Collectors.toList()); } catch (InvalidProtocolBufferException e) { @@ -72,32 +75,32 @@ public List convert(com.binance.dex.api.client.domain.jsonrpc.Block } } - public void fillTagsAndEvents(TxResult txResult,Transaction transaction){ + public void fillTagsAndEvents(TxResult txResult, Transaction transaction) { boolean hasTags = txResult.getTags() != null && txResult.getTags().size() > 0; boolean hasEvents = txResult.getEvents() != null && txResult.getEvents().size() > 0 && txResult.getEvents().get(0).getAttributes() != null && txResult.getEvents().get(0).getAttributes().size() > 0; - if(hasTags && !hasEvents){ + if (hasTags && !hasEvents) { transaction.setTags(txResult.getTags()); List attributes = txResult.getTags().stream().map(this::convertOf).collect(Collectors.toList()); TxResult.Event event = new TxResult.Event(); event.setAttributes(attributes); transaction.setEvents(Collections.singletonList(event)); - }else if(hasEvents && !hasTags){ + } else if (hasEvents && !hasTags) { transaction.setEvents(txResult.getEvents()); List tags = txResult.getEvents().get(0).getAttributes().stream().map(this::convertOf).collect(Collectors.toList()); transaction.setTags(tags); } } - private TxResult.Attribute convertOf(TxResult.Tag tag){ + private TxResult.Attribute convertOf(TxResult.Tag tag) { TxResult.Attribute attribute = new TxResult.Attribute(); attribute.setKey(tag.getKey()); attribute.setValue(tag.getValue()); return attribute; } - private TxResult.Tag convertOf(TxResult.Attribute attribute){ + private TxResult.Tag convertOf(TxResult.Attribute attribute) { TxResult.Tag tag = new TxResult.Tag(); tag.setKey(attribute.getKey()); tag.setValue(attribute.getValue()); @@ -164,6 +167,14 @@ public Transaction convert(byte[] bytes) { return convertClaimHashTimerLock(bytes); case RefundHashTimerLockMsg: return convertRefundHashTimerLock(bytes); + case TinyTokenIssue: + return convertTinyTokenIssue(bytes); + case MiniTokenIssue: + return convertMiniTokenIssue(bytes); + case MiniTokenSetURI: + return convertMiniTokenSetURI(bytes); + case MiniTokenList: + return convertMiniTokenList(bytes); } return null; @@ -172,13 +183,14 @@ public Transaction convert(byte[] bytes) { } } + private Transaction convertRefundHashTimerLock(byte[] value) throws InvalidProtocolBufferException { byte[] array = new byte[value.length - 4]; System.arraycopy(value, 4, array, 0, array.length); RefundHashTimerLockMsg refundHtlMsg = RefundHashTimerLockMsg.parseFrom(array); RefundHashTimerLock refundHashTimerLock = new RefundHashTimerLock(); - refundHashTimerLock.setFrom(Crypto.encodeAddress(hrp,refundHtlMsg.getFrom().toByteArray())); + refundHashTimerLock.setFrom(Crypto.encodeAddress(hrp, refundHtlMsg.getFrom().toByteArray())); refundHashTimerLock.setSwapID(Hex.toHexString(refundHtlMsg.getSwapId().toByteArray())); Transaction transaction = new Transaction(); @@ -193,7 +205,7 @@ private Transaction convertClaimHashTimerLock(byte[] value) throws InvalidProtoc ClaimHashTimerLockMsg claimHtlMsg = ClaimHashTimerLockMsg.parseFrom(array); ClaimHashTimerLock claimHashTimerLock = new ClaimHashTimerLock(); - claimHashTimerLock.setFrom(Crypto.encodeAddress(hrp,claimHtlMsg.getFrom().toByteArray())); + claimHashTimerLock.setFrom(Crypto.encodeAddress(hrp, claimHtlMsg.getFrom().toByteArray())); claimHashTimerLock.setSwapID(Hex.toHexString(claimHtlMsg.getSwapId().toByteArray())); claimHashTimerLock.setRandomNumber(Hex.toHexString(claimHtlMsg.getRandomNumber().toByteArray())); @@ -209,7 +221,7 @@ private Transaction convertDepositHashTimerLock(byte[] value) throws InvalidProt DepositHashTimerLockMsg depositHtlMsg = DepositHashTimerLockMsg.parseFrom(array); DepositHashTimerLock depositHashTimerLock = new DepositHashTimerLock(); - depositHashTimerLock.setFrom(Crypto.encodeAddress(hrp,depositHtlMsg.getFrom().toByteArray())); + depositHashTimerLock.setFrom(Crypto.encodeAddress(hrp, depositHtlMsg.getFrom().toByteArray())); depositHashTimerLock.setAmount(depositHtlMsg.getAmountList().stream().map(Token::of).collect(Collectors.toList())); depositHashTimerLock.setSwapID(Hex.toHexString(depositHtlMsg.getSwapId().toByteArray())); @@ -226,8 +238,8 @@ private Transaction convertHashTimerLockTransfer(byte[] value) throws InvalidPro HashTimerLockTransferMsg htlTransferMsg = HashTimerLockTransferMsg.parseFrom(array); HashTimerLockTransfer hashTimerLockTransfer = new HashTimerLockTransfer(); - hashTimerLockTransfer.setFrom(Crypto.encodeAddress(hrp,htlTransferMsg.getFrom().toByteArray())); - hashTimerLockTransfer.setTo(Crypto.encodeAddress(hrp,htlTransferMsg.getTo().toByteArray())); + hashTimerLockTransfer.setFrom(Crypto.encodeAddress(hrp, htlTransferMsg.getFrom().toByteArray())); + hashTimerLockTransfer.setTo(Crypto.encodeAddress(hrp, htlTransferMsg.getTo().toByteArray())); hashTimerLockTransfer.setRecipientOtherChain(htlTransferMsg.getRecipientOtherChain()); hashTimerLockTransfer.setSenderOtherChain(htlTransferMsg.getSenderOtherChain()); hashTimerLockTransfer.setRandomNumberHash(Hex.toHexString(htlTransferMsg.getRandomNumberHash().toByteArray())); @@ -248,7 +260,7 @@ private Transaction convertSetAccountFlag(byte[] value) throws InvalidProtocolBu System.arraycopy(value, 4, array, 0, array.length); com.binance.dex.api.proto.SetAccountFlag setAccountFlag = com.binance.dex.api.proto.SetAccountFlag.parseFrom(array); SetAccountFlag saf = new SetAccountFlag(); - saf.setFromAddr(Crypto.encodeAddress(hrp,setAccountFlag.getFrom().toByteArray())); + saf.setFromAddr(Crypto.encodeAddress(hrp, setAccountFlag.getFrom().toByteArray())); saf.setFlags(setAccountFlag.getFlags()); Transaction transaction = new Transaction(); transaction.setTxType(TxType.SetAccountFlag); @@ -261,7 +273,7 @@ private Transaction convertTimeRelock(byte[] value) throws InvalidProtocolBuffer System.arraycopy(value, 4, array, 0, array.length); TimeRelock timeRelock = TimeRelock.parseFrom(array); com.binance.dex.api.client.domain.broadcast.TimeRelock trl = new com.binance.dex.api.client.domain.broadcast.TimeRelock(); - trl.setFromAddr(Crypto.encodeAddress(hrp,timeRelock.getFrom().toByteArray())); + trl.setFromAddr(Crypto.encodeAddress(hrp, timeRelock.getFrom().toByteArray())); trl.setLockId(timeRelock.getTimeLockId()); trl.setLockTime(Date.from(Instant.ofEpochSecond(timeRelock.getLockTime()))); trl.setDescription(timeRelock.getDescription()); @@ -283,7 +295,7 @@ private Transaction convertTimeUnlock(byte[] value) throws InvalidProtocolBuffer System.arraycopy(value, 4, array, 0, array.length); TimeUnlock timeUnlock = TimeUnlock.parseFrom(array); com.binance.dex.api.client.domain.broadcast.TimeUnlock tul = new com.binance.dex.api.client.domain.broadcast.TimeUnlock(); - tul.setFromAddr(Crypto.encodeAddress(hrp,timeUnlock.getFrom().toByteArray())); + tul.setFromAddr(Crypto.encodeAddress(hrp, timeUnlock.getFrom().toByteArray())); tul.setLockId(timeUnlock.getTimeLockId()); Transaction transaction = new Transaction(); @@ -297,7 +309,7 @@ private Transaction convertTimeLock(byte[] value) throws InvalidProtocolBufferEx System.arraycopy(value, 4, array, 0, array.length); TimeLock timeLock = TimeLock.parseFrom(array); com.binance.dex.api.client.domain.broadcast.TimeLock tl = new com.binance.dex.api.client.domain.broadcast.TimeLock(); - tl.setFromAddr(Crypto.encodeAddress(hrp,timeLock.getFrom().toByteArray())); + tl.setFromAddr(Crypto.encodeAddress(hrp, timeLock.getFrom().toByteArray())); tl.setDescription(timeLock.getDescription()); tl.setLockTime(Date.from(Instant.ofEpochSecond(timeLock.getLockTime()))); List amount = timeLock.getAmountList().stream().map(token -> { @@ -507,10 +519,10 @@ private Transaction convertDeposit(byte[] value) throws InvalidProtocolBufferExc Deposit deposit = new Deposit(); deposit.setProposalId(depositMessage.getProposalId()); - deposit.setDepositer(Crypto.encodeAddress(hrp,depositMessage.getDepositer().toByteArray())); - if(null != depositMessage.getAmountList()){ + deposit.setDepositer(Crypto.encodeAddress(hrp, depositMessage.getDepositer().toByteArray())); + if (null != depositMessage.getAmountList()) { deposit.setAmount(depositMessage.getAmountList().stream() - .map(com.binance.dex.api.client.encoding.message.Token::of).collect(Collectors.toList())); + .map(com.binance.dex.api.client.encoding.message.Token::of).collect(Collectors.toList())); } Transaction transaction = new Transaction(); transaction.setTxType(TxType.DEPOSIT); @@ -525,8 +537,8 @@ private Transaction convertCreateValidator(byte[] value) throws InvalidProtocolB RealCreateValidator realCreateValidator = RealCreateValidator.parseFrom(array); CreateValidator createValidator = new CreateValidator(); - createValidator.setDelegatorAddress(Crypto.encodeAddress(hrp,realCreateValidator.getCreateValidator().getDelegatorAddress().toByteArray())); - createValidator.setValidatorAddress(Crypto.encodeAddress(hrp,realCreateValidator.getCreateValidator().getValidatorAddress().toByteArray())); + createValidator.setDelegatorAddress(Crypto.encodeAddress(hrp, realCreateValidator.getCreateValidator().getDelegatorAddress().toByteArray())); + createValidator.setValidatorAddress(Crypto.encodeAddress(hrp, realCreateValidator.getCreateValidator().getValidatorAddress().toByteArray())); createValidator.setDelegation(com.binance.dex.api.client.encoding.message.Token.of(realCreateValidator.getCreateValidator().getDelegation())); createValidator.setProposalId(realCreateValidator.getProposalId()); @@ -542,9 +554,9 @@ private Transaction convertRemoveValidator(byte[] value) throws InvalidProtocolB com.binance.dex.api.proto.RemoveValidator removeValidatorMessage = com.binance.dex.api.proto.RemoveValidator.parseFrom(array); RemoveValidator removeValidator = new RemoveValidator(); - removeValidator.setLauncherAddr(Crypto.encodeAddress(hrp,removeValidatorMessage.getLauncherAddr().toByteArray())); - removeValidator.setValAddr(Crypto.encodeAddress(hrp,removeValidatorMessage.getValAddr().toByteArray())); - removeValidator.setValConsAddr(Crypto.encodeAddress(hrp,removeValidatorMessage.getValConsAddr().toByteArray())); + removeValidator.setLauncherAddr(Crypto.encodeAddress(hrp, removeValidatorMessage.getLauncherAddr().toByteArray())); + removeValidator.setValAddr(Crypto.encodeAddress(hrp, removeValidatorMessage.getValAddr().toByteArray())); + removeValidator.setValConsAddr(Crypto.encodeAddress(hrp, removeValidatorMessage.getValConsAddr().toByteArray())); removeValidator.setProposalId(removeValidatorMessage.getProposalId()); Transaction transaction = new Transaction(); @@ -564,7 +576,7 @@ private Transaction convertListing(byte[] value) throws InvalidProtocolBufferExc listing.setBaseAssetSymbol(listMessage.getBaseAssetSymbol()); listing.setQuoteAssetSymbol(listMessage.getQuoteAssetSymbol()); listing.setInitPrice(listMessage.getInitPrice()); - listing.setFromAddr(Crypto.encodeAddress(hrp,listMessage.getFrom().toByteArray())); + listing.setFromAddr(Crypto.encodeAddress(hrp, listMessage.getFrom().toByteArray())); Transaction transaction = new Transaction(); transaction.setTxType(TxType.LISTING); @@ -573,4 +585,76 @@ private Transaction convertListing(byte[] value) throws InvalidProtocolBufferExc } + private Transaction convertTinyTokenIssue(byte[] value) throws InvalidProtocolBufferException { + byte[] array = new byte[value.length - 4]; + System.arraycopy(value, 4, array, 0, array.length); + com.binance.dex.api.proto.TinyTokenIssue issueMessage = com.binance.dex.api.proto.TinyTokenIssue.parseFrom(array); + + TinyTokenIssue issue = new TinyTokenIssue(); + issue.setFrom(Crypto.encodeAddress(hrp, issueMessage.getFrom().toByteArray())); + issue.setName(issueMessage.getName()); + issue.setSymbol(issueMessage.getSymbol()); + issue.setTotalSupply(issueMessage.getTotalSupply()); + issue.setMintable(issueMessage.getMintable()); + issue.setTokenURI(issueMessage.getTokenUri()); + + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.TINY_TOKEN_ISSUE); + transaction.setRealTx(issue); + return transaction; + } + + + private Transaction convertMiniTokenIssue(byte[] value) throws InvalidProtocolBufferException { + byte[] array = new byte[value.length - 4]; + System.arraycopy(value, 4, array, 0, array.length); + com.binance.dex.api.proto.MiniTokenIssue issueMessage = com.binance.dex.api.proto.MiniTokenIssue.parseFrom(array); + + MiniTokenIssue issue = new MiniTokenIssue(); + issue.setFrom(Crypto.encodeAddress(hrp, issueMessage.getFrom().toByteArray())); + issue.setName(issueMessage.getName()); + issue.setSymbol(issueMessage.getSymbol()); + issue.setTotalSupply(issueMessage.getTotalSupply()); + issue.setMintable(issueMessage.getMintable()); + issue.setTokenURI(issueMessage.getTokenUri()); + + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.MINI_TOKEN_ISSUE); + transaction.setRealTx(issue); + return transaction; + } + + + private Transaction convertMiniTokenSetURI(byte[] value) throws InvalidProtocolBufferException { + byte[] array = new byte[value.length - 4]; + System.arraycopy(value, 4, array, 0, array.length); + com.binance.dex.api.proto.MiniTokenSetURI uriMessage = com.binance.dex.api.proto.MiniTokenSetURI.parseFrom(array); + + MiniTokenSetURI setURI = new MiniTokenSetURI(); + setURI.setFrom(Crypto.encodeAddress(hrp, uriMessage.getFrom().toByteArray())); + setURI.setSymbol(uriMessage.getSymbol()); + setURI.setTokenURI(uriMessage.getTokenUri()); + + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.MINI_TOKEN_SET_URI); + transaction.setRealTx(setURI); + return transaction; + } + + private Transaction convertMiniTokenList(byte[] value) throws InvalidProtocolBufferException { + byte[] array = new byte[value.length - 4]; + System.arraycopy(value, 4, array, 0, array.length); + com.binance.dex.api.proto.MiniTokenList listMessage = com.binance.dex.api.proto.MiniTokenList.parseFrom(array); + + MiniTokenListing listing = new MiniTokenListing(); + listing.setFromAddr(Crypto.encodeAddress(hrp, listMessage.getFrom().toByteArray())); + listing.setBaseAssetSymbol(listMessage.getBaseAssetSymbol()); + listing.setQuoteAssetSymbol(listMessage.getQuoteAssetSymbol()); + listing.setInitPrice(listMessage.getInitPrice()); + + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.MINI_TOKEN_LIST); + transaction.setRealTx(listing); + return transaction; + } } diff --git a/src/main/java/com/binance/dex/api/client/domain/MiniToken.java b/src/main/java/com/binance/dex/api/client/domain/MiniToken.java new file mode 100644 index 0000000..f9993c1 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/MiniToken.java @@ -0,0 +1,109 @@ +package com.binance.dex.api.client.domain; + +import com.binance.dex.api.client.BinanceDexConstants; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import org.apache.commons.lang3.builder.ToStringBuilder; + +@JsonIgnoreProperties(ignoreUnknown = true) +public class MiniToken { + private String name; + private String symbol; + @JsonProperty("original_symbol") + private String originalSymbol; + @JsonProperty("total_supply") + private Long totalSupply; + @JsonProperty("token_type") + private Integer tokenType; + @JsonProperty("token_uri") + private String tokenURI; + private String owner; + private boolean mintable; + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getSymbol() { + return symbol; + } + + public void setSymbol(String symbol) { + this.symbol = symbol; + } + + public String getOriginalSymbol() { + return originalSymbol; + } + + public void setOriginalSymbol(String originalSymbol) { + this.originalSymbol = originalSymbol; + } + + public Long getTotalSupply() { + return totalSupply; + } + + public void setTotalSupply(Long totalSupply) { + this.totalSupply = totalSupply; + } + + public Integer getTokenType() { + return tokenType; + } + + public void setTokenType(Integer tokenType) { + this.tokenType = tokenType; + } + + public String getTokenURI() { + return tokenURI; + } + + public void setTokenURI(String tokenURI) { + this.tokenURI = tokenURI; + } + + public String getOwner() { + return owner; + } + + public void setOwner(String owner) { + this.owner = owner; + } + + public boolean isMintable() { + return mintable; + } + + public void setMintable(boolean mintable) { + this.mintable = mintable; + } + + public void setTotalSupply(String totalSupply){ + if (totalSupply != null) { + if (totalSupply.indexOf('.') > 0) { + totalSupply = totalSupply.substring(0, totalSupply.indexOf('.')); + this.totalSupply = Long.parseLong(totalSupply) * 100000000L; + } + } + } + + @Override + public String toString() { + return new ToStringBuilder(this, BinanceDexConstants.BINANCE_DEX_TO_STRING_STYLE) + .append("name", name) + .append("symbol", symbol) + .append("originalSymbol", originalSymbol) + .append("totalSupply", totalSupply) + .append("tokenType", tokenType) + .append("tokenURI", tokenURI) + .append("owner", owner) + .append("mintable", mintable) + .toString(); + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/Token.java b/src/main/java/com/binance/dex/api/client/domain/Token.java index 30c5060..970eccd 100644 --- a/src/main/java/com/binance/dex/api/client/domain/Token.java +++ b/src/main/java/com/binance/dex/api/client/domain/Token.java @@ -75,4 +75,13 @@ public void setTotalSupply(Long totalSupply) { public Long getTotalSupply() { return totalSupply; } + + public void setTotalSupply(String totalSupply){ + if (totalSupply != null) { + if (totalSupply.indexOf('.') > 0) { + totalSupply = totalSupply.substring(0, totalSupply.indexOf('.')); + this.totalSupply = Long.parseLong(totalSupply) * 100000000L; + } + } + } } diff --git a/src/main/java/com/binance/dex/api/client/domain/broadcast/MiniTokenIssue.java b/src/main/java/com/binance/dex/api/client/domain/broadcast/MiniTokenIssue.java new file mode 100644 index 0000000..7edfd26 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/broadcast/MiniTokenIssue.java @@ -0,0 +1,26 @@ +package com.binance.dex.api.client.domain.broadcast; + +public class MiniTokenIssue extends Issue { + private String tokenURI; + + public String getTokenURI() { + return tokenURI; + } + + public void setTokenURI(String tokenURI) { + this.tokenURI = tokenURI; + } + + @Override + public String toString() { + return "MiniTokenIssue{" + + "from='" + super.getFrom() + '\'' + + ", name='" + super.getName() + '\'' + + ", symbol='" + super.getSymbol() + '\'' + + ", totalSupply=" + super.getTotalSupply() + + ", tokenURI=" + tokenURI + + ", mintable=" + super.getMintable() + + '}'; + } + +} \ No newline at end of file diff --git a/src/main/java/com/binance/dex/api/client/domain/broadcast/MiniTokenListing.java b/src/main/java/com/binance/dex/api/client/domain/broadcast/MiniTokenListing.java new file mode 100644 index 0000000..8476112 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/broadcast/MiniTokenListing.java @@ -0,0 +1,51 @@ +package com.binance.dex.api.client.domain.broadcast; + +public class MiniTokenListing { + + private String fromAddr; + private String baseAssetSymbol; + private String quoteAssetSymbol; + private Long initPrice; + + public String getFromAddr() { + return fromAddr; + } + + public void setFromAddr(String fromAddr) { + this.fromAddr = fromAddr; + } + + public String getBaseAssetSymbol() { + return baseAssetSymbol; + } + + public void setBaseAssetSymbol(String baseAssetSymbol) { + this.baseAssetSymbol = baseAssetSymbol; + } + + public String getQuoteAssetSymbol() { + return quoteAssetSymbol; + } + + public void setQuoteAssetSymbol(String quoteAssetSymbol) { + this.quoteAssetSymbol = quoteAssetSymbol; + } + + public Long getInitPrice() { + return initPrice; + } + + public void setInitPrice(Long initPrice) { + this.initPrice = initPrice; + } + + @Override + public String toString() { + return "MiniTokenListing{" + + "fromAddr='" + fromAddr + '\'' + + ", baseAssetSymbol='" + baseAssetSymbol + '\'' + + ", quoteAssetSymbol='" + quoteAssetSymbol + '\'' + + ", initPrice=" + initPrice + + '}'; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/broadcast/MiniTokenSetURI.java b/src/main/java/com/binance/dex/api/client/domain/broadcast/MiniTokenSetURI.java new file mode 100644 index 0000000..428852c --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/broadcast/MiniTokenSetURI.java @@ -0,0 +1,41 @@ +package com.binance.dex.api.client.domain.broadcast; + +public class MiniTokenSetURI { + + private String from; + private String symbol; + private String tokenURI; + + public String getFrom() { + return from; + } + + public void setFrom(String from) { + this.from = from; + } + + public String getSymbol() { + return symbol; + } + + public void setSymbol(String symbol) { + this.symbol = symbol; + } + + public String getTokenURI() { + return tokenURI; + } + + public void setTokenURI(String tokenURI) { + this.tokenURI = tokenURI; + } + + @Override + public String toString() { + return "MiniTokenSetURI{" + + "from='" + from + '\'' + + ", symbol='" + symbol + '\'' + + ", tokenURI='" + tokenURI + '\'' + + '}'; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/broadcast/TinyTokenIssue.java b/src/main/java/com/binance/dex/api/client/domain/broadcast/TinyTokenIssue.java new file mode 100644 index 0000000..617571b --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/broadcast/TinyTokenIssue.java @@ -0,0 +1,26 @@ +package com.binance.dex.api.client.domain.broadcast; + +public class TinyTokenIssue extends Issue { + private String tokenURI; + + public String getTokenURI() { + return tokenURI; + } + + public void setTokenURI(String tokenURI) { + this.tokenURI = tokenURI; + } + + @Override + public String toString() { + return "TinyTokenIssue{" + + "from='" + super.getFrom() + '\'' + + ", name='" + super.getName() + '\'' + + ", symbol='" + super.getSymbol() + '\'' + + ", totalSupply=" + super.getTotalSupply() + + ", tokenURI=" + tokenURI + + ", mintable=" + super.getMintable() + + '}'; + } + +} \ No newline at end of file diff --git a/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java b/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java index ca50fdd..03107b2 100644 --- a/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java +++ b/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java @@ -22,5 +22,9 @@ public enum TxType { HTL_TRANSFER, CLAIM_HTL, REFUND_HTL, - DEPOSIT_HTL + DEPOSIT_HTL, + TINY_TOKEN_ISSUE, + MINI_TOKEN_ISSUE, + MINI_TOKEN_SET_URI, + MINI_TOKEN_LIST } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java b/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java index b3bd921..7690ee2 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java @@ -5,7 +5,7 @@ import java.util.Arrays; /** - * Binance dex standard transactiont types. + * Binance dex standard transaction types. */ public enum MessageType { Send("2A2C87FA"), @@ -32,7 +32,14 @@ public enum MessageType { HashTimerLockTransferMsg("B33F9A24"), DepositHashTimerLockMsg("63986496"), ClaimHashTimerLockMsg("C1665300"), - RefundHashTimerLockMsg("3454A27C"); + RefundHashTimerLockMsg("3454A27C"), + + //mini token + TinyTokenIssue("ED2832D4"), + MiniTokenIssue("A3F16C41"), + MiniTokenSetURI("7B1D34E7"), + MiniTokenList("4C264019"); + private byte[] typePrefixBytes; MessageType(String typePrefix) { diff --git a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java index e964d5b..f820b44 100644 --- a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java +++ b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java @@ -351,6 +351,23 @@ public List broadcast(String payload, boolean sync) { } } + @Override + public com.binance.dex.api.client.domain.MiniToken getMiniTokenInfoBySymbol(String symbol) { + try { + String pathWithSymbol = "\"mini-tokens/info/" + symbol + "\""; + JsonRpcResponse rpcResponse = BinanceDexApiClientGenerator.executeSync(binanceDexNodeApi.getTokenInfo(pathWithSymbol)); + checkRpcResult(rpcResponse); + byte[] value = rpcResponse.getResult().getResponse().getValue(); + int startIndex = getStartIndex(value); + byte[] array = new byte[value.length - startIndex]; + System.arraycopy(value, startIndex, array, 0, array.length); + MiniTokenInfo tokenInfo = MiniTokenInfo.parseFrom(array); + return convert(tokenInfo); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + protected Infos convert(NodeInfos nodeInfos) { Infos infos = new Infos(); @@ -404,6 +421,19 @@ protected com.binance.dex.api.client.domain.Token convert(TokenInfo tokenInfo) { return token; } + protected com.binance.dex.api.client.domain.MiniToken convert(MiniTokenInfo tokenInfo) { + com.binance.dex.api.client.domain.MiniToken token = new com.binance.dex.api.client.domain.MiniToken(); + token.setName(tokenInfo.getName()); + token.setOriginalSymbol(tokenInfo.getOriginalSymbol()); + token.setSymbol(tokenInfo.getSymbol()); + token.setOwner(Crypto.encodeAddress(hrp, tokenInfo.getOwner().toByteArray())); + token.setTotalSupply(tokenInfo.getTotalSupply()); + token.setMintable(tokenInfo.getMintable()); + token.setTokenType(tokenInfo.getTokenType()); + token.setTokenURI(tokenInfo.getTokenUri()); + return token; + } + protected List syncBroadcast(String requestBody, Wallet wallet) { try { JsonRpcResponse rpcResponse = BinanceDexApiClientGenerator.executeSync(binanceDexNodeApi.commitBroadcast(requestBody)); diff --git a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiRestClientImpl.java b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiRestClientImpl.java index 081d0e2..e6fa28b 100644 --- a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiRestClientImpl.java +++ b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiRestClientImpl.java @@ -179,6 +179,91 @@ private List broadcast(RequestBody requestBody, boolean syn } } + @Override + public List getMiniTokens(Integer limit) { + return BinanceDexApiClientGenerator.executeSync(binanceDexApi.getMiniTokens(limit)); + } + + @Override + public List getMiniMarkets(Integer limit) { + return BinanceDexApiClientGenerator.executeSync(binanceDexApi.getMiniMarkets(limit)); + } + + @Override + public List getMiniCandleStickBars(String symbol, CandlestickInterval interval) { + return getMiniCandleStickBars(symbol, interval, null, null, null); + } + + @Override + public List getMiniCandleStickBars(String symbol, CandlestickInterval interval, Integer limit, Long startTime, Long endTime) { + return BinanceDexApiClientGenerator.executeSync(binanceDexApi.getMiniCandlestickBars(symbol, interval.getIntervalId(), limit, startTime, endTime)); + } + + @Override + public OrderList getMiniOpenOrders(String address) { + OpenOrdersRequest request = new OpenOrdersRequest(); + request.setAddress(address); + return getMiniOpenOrders(request); + } + + @Override + public OrderList getMiniOpenOrders(OpenOrdersRequest request) { + return BinanceDexApiClientGenerator.executeSync( + binanceDexApi.getMiniOpenOrders(request.getAddress(), request.getLimit(), + request.getOffset(), request.getSymbol(), request.getTotal())); + } + + @Override + public OrderList getMiniClosedOrders(String address) { + ClosedOrdersRequest request = new ClosedOrdersRequest(); + request.setAddress(address); + return getMiniClosedOrders(request); + } + + @Override + public OrderList getMiniClosedOrders(ClosedOrdersRequest request) { + Integer side = request.getSide() == null ? null : (int)(request.getSide().toValue()); + List statusStrList = null; + if (request.getStatus() != null) + statusStrList = request.getStatus().stream().map(s -> s.name()).collect(Collectors.toList()); + return BinanceDexApiClientGenerator.executeSync( + binanceDexApi.getMiniClosedOrders(request.getAddress(), request.getEnd(), request.getLimit(), + request.getLimit(), side, request.getStart(), statusStrList, request.getSymbol(), + request.getTotal())); + } + + @Override + public Order getMiniOrder(String id) { + return BinanceDexApiClientGenerator.executeSync(binanceDexApi.getMiniOrder(id)); + } + + @Override + public List getMini24HrPriceStatistics() { + return BinanceDexApiClientGenerator.executeSync(binanceDexApi.getMini24HrPriceStatistics()); + } + + @Override + public List getMini24HrPriceStatistics(String symbol) { + return BinanceDexApiClientGenerator.executeSync(binanceDexApi.getMini24HrPriceStatistics(symbol)); + } + + @Override + public TradePage getMiniTrades() { + TradesRequest request = new TradesRequest(); + return getMiniTrades(request); + } + + @Override + public TradePage getMiniTrades(TradesRequest request) { + Integer side = request.getSide() == null ? null : (int)(request.getSide().toValue()); + return BinanceDexApiClientGenerator.executeSync( + binanceDexApi.getMiniTrades( + request.getAddress(), request.getBuyerOrderId(), + request.getEnd(), request.getHeight(), request.getLimit(), request.getOffset(), + request.getQuoteAsset(), request.getSellerOrderId(), side, + request.getStart(), request.getSymbol(), request.getTotal())); + } + public List newOrder(NewOrder newOrder, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { wallet.ensureWalletIsReady(this); diff --git a/src/main/proto/dex.proto b/src/main/proto/dex.proto index a46f521..0f2df31 100644 --- a/src/main/proto/dex.proto +++ b/src/main/proto/dex.proto @@ -148,6 +148,16 @@ message TokenInfo{ bool mintable = 6; } +message MiniTokenInfo{ + string name = 1; + string symbol = 2; + string original_symbol = 3; + int64 total_supply = 4; + bytes owner = 5; + bool mintable = 6; + int32 token_type = 7; + string token_uri = 8; +} message DexFeeParam { // 0x495A5044 @@ -345,4 +355,40 @@ message RefundHashTimerLockMsg { // bytes from = 1; bytes swap_id = 2; +} + +//mini token issue +message TinyTokenIssue { + // ED2832D4 // hardcoded, object type prefix in 4 bytes + bytes from = 1; // issue token owner + string name = 2; + string symbol = 3; + int64 total_supply = 4; + bool mintable = 5; + string token_uri = 6; +} + +message MiniTokenIssue { + // A3F16C41 // hardcoded, object type prefix in 4 bytes + bytes from = 1; // issue token owner + string name = 2; + string symbol = 3; + int64 total_supply = 4; + bool mintable = 5; + string token_uri = 6; +} + +message MiniTokenSetURI { + // 7B1D34E7 // hardcoded, object type prefix in 4 bytes + bytes from = 1; // issue token owner + string symbol = 2; + string token_uri = 3; +} + +message MiniTokenList { + // 4C264019 // hardcoded, object type prefix in 4 bytes + bytes from = 1; + string base_asset_symbol = 2; + string quote_asset_symbol = 3; + int64 init_price = 4; } \ No newline at end of file diff --git a/src/test/java/com/binance/dex/api/client/encoding/message/TestRestClient.java b/src/test/java/com/binance/dex/api/client/encoding/message/TestRestClient.java index 92fa924..dec51f8 100644 --- a/src/test/java/com/binance/dex/api/client/encoding/message/TestRestClient.java +++ b/src/test/java/com/binance/dex/api/client/encoding/message/TestRestClient.java @@ -14,12 +14,14 @@ @Ignore("Manual run only") public class TestRestClient { private BinanceDexApiRestClient client = - BinanceDexApiClientFactory.newInstance().newRestClient(BinanceDexEnvironment.TEST_NET.getBaseUrl()); + BinanceDexApiClientFactory.newInstance().newRestClient("https://dex-api.fdgahl.cn"); private String address = "tbnb16hywxpvvkaz6cecjz89mf2w0da3vfeg6z6yky2"; private String symbol = "ADA.B-F2F_BNB"; + private String miniSymbol = "MSDK-400M_BNB"; + @Test public void testGetMarkets() { List mkts = client.getMarkets(1000); @@ -125,4 +127,52 @@ public void testGetFees() { List fees = client.getFees(); System.out.println(fees); } + + @Test + public void testGetMiniToken() { + List tokens = client.getMiniTokens(100); + System.out.println(tokens); + } + + @Test + public void testGetMiniMarkets() { + List mkts = client.getMiniMarkets(1000); + for (Market m : mkts) { + System.out.println(m); + } + } + + @Test + public void testGetMiniCandlestickBars() { + List klines = client.getMiniCandleStickBars(miniSymbol, CandlestickInterval.HOURLY); + System.out.println(klines); + + System.out.println(client.getMiniCandleStickBars(miniSymbol, CandlestickInterval.ONE_MINUTE, + 10, System.currentTimeMillis() - 24L * 60 * 60 * 1000L, null)); + } + + @Test + public void testGetMiniOpenOrders() { + System.out.println(client.getMiniOpenOrders(address)); + } + + @Test + public void testGetMiniClosedOrders() { + System.out.println(client.getMiniClosedOrders(address)); + } + + @Test + public void testGetMini24HrPriceStatistics() { + System.out.println(client.getMini24HrPriceStatistics()); + System.out.println(client.getMini24HrPriceStatistics(miniSymbol)); + } + + @Test + public void testGetMiniTrades() { + System.out.println(client.getMiniTrades()); + TradesRequest request = new TradesRequest(); + request.setAddress(address); + request.setLimit(10); + System.out.println(client.getMiniTrades(request)); + } } diff --git a/src/test/java/com/binance/dex/api/client/examples/BinanceDexWSApiExample.java b/src/test/java/com/binance/dex/api/client/examples/BinanceDexWSApiExample.java index b040617..f85465c 100644 --- a/src/test/java/com/binance/dex/api/client/examples/BinanceDexWSApiExample.java +++ b/src/test/java/com/binance/dex/api/client/examples/BinanceDexWSApiExample.java @@ -54,9 +54,9 @@ public void testNetInfo(){ @Test public void testBlockByHeight() { - BlockMeta.BlockMetaResult result = binanceDexWSApi.blockByHeight(13513018L); + BlockMeta.BlockMetaResult result = binanceDexWSApi.blockByHeight(18L); Assert.assertNotNull(result); - Assert.assertEquals(13513018L,result.getBlockMeta().getHeader().getHeight().longValue()); + Assert.assertEquals(18L,result.getBlockMeta().getHeader().getHeight().longValue()); } @Test diff --git a/src/test/java/com/binance/dex/api/client/examples/LocalEnvironmentExample.java b/src/test/java/com/binance/dex/api/client/examples/LocalEnvironmentExample.java new file mode 100644 index 0000000..40e0a99 --- /dev/null +++ b/src/test/java/com/binance/dex/api/client/examples/LocalEnvironmentExample.java @@ -0,0 +1,53 @@ +package com.binance.dex.api.client.examples; + +import com.binance.dex.api.client.BinanceDexApiClientFactory; +import com.binance.dex.api.client.BinanceDexApiNodeClient; +import com.binance.dex.api.client.BinanceDexEnvironment; +import com.binance.dex.api.client.domain.broadcast.Transaction; +import com.binance.dex.api.client.domain.broadcast.TxType; +import org.junit.Assert; + +import java.util.List; + +public class LocalEnvironmentExample { + public static void main(String[] args) { + BinanceDexEnvironment env = new BinanceDexEnvironment( + "http://seed-qa-s3.fdgahl.cn:80", + "", + "http://seed-qa-s3.fdgahl.cn:80", + "", + "tbnb"); + + + BinanceDexApiNodeClient binanceDexNodeApi = BinanceDexApiClientFactory.newInstance().newNodeRpcClient(env.getNodeUrl(), env.getHrp()); +// Long height = 225L; +// List transactions = binanceDexNodeApi.getBlockTransactions(height); +// Assert.assertNotNull(transactions); +// Assert.assertTrue(transactions.size() == 1); +// Assert.assertEquals(transactions.get(0).getTxType(), TxType.MINI_TOKEN_ISSUE); +// +// height = 228L; +// transactions = binanceDexNodeApi.getBlockTransactions(height); +// Assert.assertNotNull(transactions); +// Assert.assertTrue(transactions.size() == 1); +// Assert.assertEquals(transactions.get(0).getTxType(), TxType.MINI_TOKEN_LIST); + + Long height = 1892273L; + List transactions = binanceDexNodeApi.getBlockTransactions(height); + Assert.assertNotNull(transactions); + Assert.assertTrue(transactions.size() == 1); + Assert.assertEquals(transactions.get(0).getTxType(), TxType.TINY_TOKEN_ISSUE); + + height = 148L; + transactions = binanceDexNodeApi.getBlockTransactions(height); + Assert.assertNotNull(transactions); + Assert.assertTrue(transactions.size() == 1); + Assert.assertEquals(transactions.get(0).getTxType(), TxType.MINI_TOKEN_LIST); + + height = 4747L; + transactions = binanceDexNodeApi.getBlockTransactions(height); + Assert.assertNotNull(transactions); + Assert.assertTrue(transactions.size() == 1); + Assert.assertEquals(transactions.get(0).getTxType(), TxType.MINI_TOKEN_SET_URI); + } +} diff --git a/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java b/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java index 2c20c8a..4c8bd52 100644 --- a/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java +++ b/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java @@ -232,6 +232,13 @@ public void testGetTokenInfoBySymbol(){ Assert.assertEquals("BNB",token.getSymbol()); } + @Test + public void testGetMiniTokenInfoBySymbol(){ + MiniToken token = binanceDexNodeApi.getMiniTokenInfoBySymbol("AT10-1DEM"); + Assert.assertNotNull(token); + Assert.assertEquals("AT10-1DEM",token.getSymbol()); + } + @Test public void testGetFees() { List feesList = binanceDexNodeApi.getFees(); From b51fd9fef0151248876ba025bfdae82ebf1161d6 Mon Sep 17 00:00:00 2001 From: erhenglu <42333959+erhenglu@users.noreply.github.com> Date: Mon, 1 Jun 2020 17:25:53 +0800 Subject: [PATCH 09/52] add pending_match in depth response (#86) * add pending_match in depth response --- CHANGELOG.md | 4 ++-- .../binance/dex/api/client/domain/OrderBook.java | 15 +++++++++++++++ 2 files changed, 17 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index b694498..85ba806 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,5 @@ # Changelog ## 1.0.7 CHAIN UPGRADE -* [\#110](https://github.com/binance-chain/java-sdk/pull/84) [RPC] [API] Add Pending match flag to Depth API response -* [\#115](https://github.com/binance-chain/java-sdk/pull/80) [RPC] [API] Support Mini Token \ No newline at end of file +* [\#86](https://github.com/binance-chain/java-sdk/pull/86) [RPC] [API] Add Pending match flag to Depth API response +* [\#80](https://github.com/binance-chain/java-sdk/pull/80) [RPC] [API] Support Mini Token \ No newline at end of file diff --git a/src/main/java/com/binance/dex/api/client/domain/OrderBook.java b/src/main/java/com/binance/dex/api/client/domain/OrderBook.java index ba9f9af..8ad403d 100644 --- a/src/main/java/com/binance/dex/api/client/domain/OrderBook.java +++ b/src/main/java/com/binance/dex/api/client/domain/OrderBook.java @@ -2,15 +2,20 @@ import com.binance.dex.api.client.BinanceDexConstants; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; import org.apache.commons.lang3.builder.ToStringBuilder; import java.util.List; @JsonIgnoreProperties(ignoreUnknown = true) +@JsonInclude(JsonInclude.Include.NON_NULL) public class OrderBook { private List asks; private List bids; private long height; + @JsonProperty("pending_match") + private Boolean pendingMatch; public List getAsks() { return asks; @@ -36,12 +41,22 @@ public void setHeight(long height) { this.height = height; } + public boolean isPendingMatch() { + return pendingMatch; + } + + public void setPendingMatch(boolean pendingMatch) { + this.pendingMatch = pendingMatch; + } + @Override public String toString() { return new ToStringBuilder(this, BinanceDexConstants.BINANCE_DEX_TO_STRING_STYLE) .append("asks", asks) .append("bids", bids) .append("height", height) + .append("pendingMatch", pendingMatch) .toString(); } + } From b2ae92f0ace2e982eef6b4c683bea3ef85de8f04 Mon Sep 17 00:00:00 2001 From: George <61674316+forcodedancing@users.noreply.github.com> Date: Mon, 15 Jun 2020 19:59:39 +0800 Subject: [PATCH 10/52] update mvn artifact version (#87) --- README.md | 2 +- .../examples/LocalEnvironmentExample.java | 53 ------------------- .../client/examples/NodeClientExample.java | 35 ++++++++++-- 3 files changed, 32 insertions(+), 58 deletions(-) delete mode 100644 src/test/java/com/binance/dex/api/client/examples/LocalEnvironmentExample.java diff --git a/README.md b/README.md index 0dbb9c8..65b56a1 100644 --- a/README.md +++ b/README.md @@ -17,7 +17,7 @@ The Binance Chain Java SDK works as a lightweight Java library for interacting w com.binance.dex.api binance-dex-api-client - 1.0.4 + 1.0.7 ``` # Protobuf diff --git a/src/test/java/com/binance/dex/api/client/examples/LocalEnvironmentExample.java b/src/test/java/com/binance/dex/api/client/examples/LocalEnvironmentExample.java deleted file mode 100644 index 40e0a99..0000000 --- a/src/test/java/com/binance/dex/api/client/examples/LocalEnvironmentExample.java +++ /dev/null @@ -1,53 +0,0 @@ -package com.binance.dex.api.client.examples; - -import com.binance.dex.api.client.BinanceDexApiClientFactory; -import com.binance.dex.api.client.BinanceDexApiNodeClient; -import com.binance.dex.api.client.BinanceDexEnvironment; -import com.binance.dex.api.client.domain.broadcast.Transaction; -import com.binance.dex.api.client.domain.broadcast.TxType; -import org.junit.Assert; - -import java.util.List; - -public class LocalEnvironmentExample { - public static void main(String[] args) { - BinanceDexEnvironment env = new BinanceDexEnvironment( - "http://seed-qa-s3.fdgahl.cn:80", - "", - "http://seed-qa-s3.fdgahl.cn:80", - "", - "tbnb"); - - - BinanceDexApiNodeClient binanceDexNodeApi = BinanceDexApiClientFactory.newInstance().newNodeRpcClient(env.getNodeUrl(), env.getHrp()); -// Long height = 225L; -// List transactions = binanceDexNodeApi.getBlockTransactions(height); -// Assert.assertNotNull(transactions); -// Assert.assertTrue(transactions.size() == 1); -// Assert.assertEquals(transactions.get(0).getTxType(), TxType.MINI_TOKEN_ISSUE); -// -// height = 228L; -// transactions = binanceDexNodeApi.getBlockTransactions(height); -// Assert.assertNotNull(transactions); -// Assert.assertTrue(transactions.size() == 1); -// Assert.assertEquals(transactions.get(0).getTxType(), TxType.MINI_TOKEN_LIST); - - Long height = 1892273L; - List transactions = binanceDexNodeApi.getBlockTransactions(height); - Assert.assertNotNull(transactions); - Assert.assertTrue(transactions.size() == 1); - Assert.assertEquals(transactions.get(0).getTxType(), TxType.TINY_TOKEN_ISSUE); - - height = 148L; - transactions = binanceDexNodeApi.getBlockTransactions(height); - Assert.assertNotNull(transactions); - Assert.assertTrue(transactions.size() == 1); - Assert.assertEquals(transactions.get(0).getTxType(), TxType.MINI_TOKEN_LIST); - - height = 4747L; - transactions = binanceDexNodeApi.getBlockTransactions(height); - Assert.assertNotNull(transactions); - Assert.assertTrue(transactions.size() == 1); - Assert.assertEquals(transactions.get(0).getTxType(), TxType.MINI_TOKEN_SET_URI); - } -} diff --git a/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java b/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java index 4c8bd52..c9ef431 100644 --- a/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java +++ b/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java @@ -47,10 +47,37 @@ public void testCommittedAccount(){ @Test public void testBlockTransactions() { + //Mini Issue + Long height = 87908207L; + List transactions = binanceDexNodeApi.getBlockTransactions(height); + Assert.assertNotNull(transactions); + Assert.assertTrue(transactions.size() == 1); + Assert.assertEquals(transactions.get(0).getTxType(), TxType.MINI_TOKEN_ISSUE); + + //Tiny Issue + height = 86888933L; + transactions = binanceDexNodeApi.getBlockTransactions(height); + Assert.assertNotNull(transactions); + Assert.assertTrue(transactions.size() == 1); + Assert.assertEquals(transactions.get(0).getTxType(), TxType.TINY_TOKEN_ISSUE); + + //List Mini + height = 86890587L; + transactions = binanceDexNodeApi.getBlockTransactions(height); + Assert.assertNotNull(transactions); + Assert.assertTrue(transactions.size() == 1); + Assert.assertEquals(transactions.get(0).getTxType(), TxType.MINI_TOKEN_LIST); + + //Set token uri + height = 86881980L; + transactions = binanceDexNodeApi.getBlockTransactions(height); + Assert.assertNotNull(transactions); + Assert.assertTrue(transactions.size() == 1); + Assert.assertEquals(transactions.get(0).getTxType(), TxType.MINI_TOKEN_SET_URI); //Transfer - Long height = 33896036L; - List transactions = binanceDexNodeApi.getBlockTransactions(height); + height = 33896036L; + transactions = binanceDexNodeApi.getBlockTransactions(height); Assert.assertNotNull(transactions); Assert.assertTrue(transactions.size() == 1); Assert.assertEquals(transactions.get(0).getTxType(), TxType.TRANSFER); @@ -234,9 +261,9 @@ public void testGetTokenInfoBySymbol(){ @Test public void testGetMiniTokenInfoBySymbol(){ - MiniToken token = binanceDexNodeApi.getMiniTokenInfoBySymbol("AT10-1DEM"); + MiniToken token = binanceDexNodeApi.getMiniTokenInfoBySymbol("TTT-873M"); Assert.assertNotNull(token); - Assert.assertEquals("AT10-1DEM",token.getSymbol()); + Assert.assertEquals("TTT-873M",token.getSymbol()); } @Test From d81d9dcaf1604fa2571c1bd2fc4b81fc7886473f Mon Sep 17 00:00:00 2001 From: fudongbai <296179868@qq.com> Date: Wed, 1 Jul 2020 15:46:50 +0800 Subject: [PATCH 11/52] support side chain gov --- .../api/client/BinanceDexApiNodeClient.java | 2 + .../api/client/BinanceDexApiRestClient.java | 2 + .../dex/api/client/TransactionConverter.java | 70 +++++++++++++++ .../client/domain/broadcast/SideDeposit.java | 47 ++++++++++ .../domain/broadcast/SideSubmitProposal.java | 85 +++++++++++++++++++ .../api/client/domain/broadcast/SideVote.java | 54 ++++++++++++ .../api/client/domain/broadcast/TxType.java | 3 + .../client/encoding/message/MessageType.java | 3 + .../encoding/message/SideVoteMessage.java | 67 +++++++++++++++ .../message/TransactionRequestAssembler.java | 34 ++++++++ .../sidechain/query/QuerySideProposal.java | 33 +++++++ .../impl/BinanceDexApiNodeClientImpl.java | 46 +++++++++- .../impl/BinanceDexApiRestClientImpl.java | 8 ++ src/main/proto/dex.proto | 27 ++++++ .../client/examples/NodeClientExample.java | 10 ++- .../api/client/examples/SideVoteExample.java | 31 +++++++ 16 files changed, 516 insertions(+), 6 deletions(-) create mode 100644 src/main/java/com/binance/dex/api/client/domain/broadcast/SideDeposit.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/broadcast/SideSubmitProposal.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/broadcast/SideVote.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/SideVoteMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QuerySideProposal.java create mode 100644 src/test/java/com/binance/dex/api/client/examples/SideVoteExample.java diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java b/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java index b8d7030..c3dfcce 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java @@ -33,6 +33,8 @@ public interface BinanceDexApiNodeClient extends BinanceDexApiRestClient { Proposal getProposalById(String proposalId); + Proposal getSideProposalById(String proposalId, String sideChainId); + Account getCommittedAccount(String address); AtomicSwap getSwapByID(String swapID); diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexApiRestClient.java b/src/main/java/com/binance/dex/api/client/BinanceDexApiRestClient.java index 17706e4..630cbbf 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexApiRestClient.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexApiRestClient.java @@ -65,6 +65,8 @@ List newOrder(NewOrder newOrder, Wallet wallet, Transaction List vote(Vote vote,Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; + List sideVote(SideVote vote,Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; + List cancelOrder(CancelOrder cancelOrder, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; diff --git a/src/main/java/com/binance/dex/api/client/TransactionConverter.java b/src/main/java/com/binance/dex/api/client/TransactionConverter.java index 0e166a9..8751340 100644 --- a/src/main/java/com/binance/dex/api/client/TransactionConverter.java +++ b/src/main/java/com/binance/dex/api/client/TransactionConverter.java @@ -13,6 +13,9 @@ import com.binance.dex.api.client.domain.broadcast.Mint; import com.binance.dex.api.client.domain.broadcast.NewOrder; import com.binance.dex.api.client.domain.broadcast.SetAccountFlag; +import com.binance.dex.api.client.domain.broadcast.SideDeposit; +import com.binance.dex.api.client.domain.broadcast.SideSubmitProposal; +import com.binance.dex.api.client.domain.broadcast.SideVote; import com.binance.dex.api.client.domain.broadcast.SubmitProposal; import com.binance.dex.api.client.domain.broadcast.TokenFreeze; import com.binance.dex.api.client.domain.broadcast.TokenUnfreeze; @@ -152,6 +155,8 @@ public Transaction convert(byte[] bytes) { return convertTokenUnfreeze(bytes); case Vote: return convertVote(bytes); + case SideVote: + return convertSideVote(bytes); case Issue: return convertIssue(bytes); case Burn: @@ -160,8 +165,12 @@ public Transaction convert(byte[] bytes) { return convertMint(bytes); case SubmitProposal: return convertSubmitProposal(bytes); + case SideSubmitProposal: + return convertSideSubmitProposal(bytes); case Deposit: return convertDeposit(bytes); + case SideDeposit: + return convertSideDeposit(bytes); case CreateValidator: return convertCreateValidator(bytes); case RemoveValidator: @@ -786,6 +795,24 @@ protected Transaction convertVote(byte[] value) throws InvalidProtocolBufferExce return transaction; } + protected Transaction convertSideVote(byte[] value) throws InvalidProtocolBufferException { + byte[] array = new byte[value.length - 4]; + System.arraycopy(value, 4, array, 0, array.length); + com.binance.dex.api.proto.SideVote voteMessage = com.binance.dex.api.proto.SideVote.parseFrom(array); + + SideVote vote = new SideVote(); + + vote.setVoter(Crypto.encodeAddress(hrp, voteMessage.getVoter().toByteArray())); + vote.setOption((int) voteMessage.getOption()); + vote.setProposalId(voteMessage.getProposalId()); + vote.setSideChainId(voteMessage.getSideChainId()); + + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.SIDE_VOTE); + transaction.setRealTx(vote); + return transaction; + } + protected Transaction convertIssue(byte[] value) throws InvalidProtocolBufferException { byte[] array = new byte[value.length - 4]; System.arraycopy(value, 4, array, 0, array.length); @@ -859,6 +886,30 @@ protected Transaction convertSubmitProposal(byte[] value) throws InvalidProtocol return transaction; } + protected Transaction convertSideSubmitProposal(byte[] value) throws InvalidProtocolBufferException { + byte[] array = new byte[value.length - 4]; + System.arraycopy(value, 4, array, 0, array.length); + com.binance.dex.api.proto.SideSubmitProposal proposalMessage = com.binance.dex.api.proto.SideSubmitProposal.parseFrom(array); + + SideSubmitProposal proposal = new SideSubmitProposal(); + proposal.setTitle(proposalMessage.getTitle()); + proposal.setDescription(proposalMessage.getDescription()); + proposal.setProposalType(ProposalType.fromValue(proposalMessage.getProposalType())); + proposal.setProposer(Crypto.encodeAddress(hrp, proposalMessage.getProposer().toByteArray())); + + if (null != proposalMessage.getInitialDepositList()) { + proposal.setInitDeposit(proposalMessage.getInitialDepositList().stream() + .map(com.binance.dex.api.client.encoding.message.Token::of).collect(Collectors.toList())); + } + proposal.setVotingPeriod(proposalMessage.getVotingPeriod()); + + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.SIDE_SUBMIT_PROPOSAL); + transaction.setRealTx(proposal); + proposal.setSideChainId(proposalMessage.getSideChainId()); + return transaction; + } + private Transaction convertDeposit(byte[] value) throws InvalidProtocolBufferException { byte[] array = new byte[value.length - 4]; System.arraycopy(value, 4, array, 0, array.length); @@ -877,6 +928,25 @@ private Transaction convertDeposit(byte[] value) throws InvalidProtocolBufferExc return transaction; } + private Transaction convertSideDeposit(byte[] value) throws InvalidProtocolBufferException { + byte[] array = new byte[value.length - 4]; + System.arraycopy(value, 4, array, 0, array.length); + com.binance.dex.api.proto.SideDeposit depositMessage = com.binance.dex.api.proto.SideDeposit.parseFrom(array); + + SideDeposit deposit = new SideDeposit(); + deposit.setProposalId(depositMessage.getProposalId()); + deposit.setDepositer(Crypto.encodeAddress(hrp, depositMessage.getDepositer().toByteArray())); + if (null != depositMessage.getAmountList()) { + deposit.setAmount(depositMessage.getAmountList().stream() + .map(com.binance.dex.api.client.encoding.message.Token::of).collect(Collectors.toList())); + } + deposit.setSideChainId(depositMessage.getSideChainId()); + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.SIDE_DEPOSIT); + transaction.setRealTx(deposit); + return transaction; + } + private Transaction convertCreateValidator(byte[] value) throws InvalidProtocolBufferException { byte[] array = new byte[value.length - 4]; System.arraycopy(value, 4, array, 0, array.length); diff --git a/src/main/java/com/binance/dex/api/client/domain/broadcast/SideDeposit.java b/src/main/java/com/binance/dex/api/client/domain/broadcast/SideDeposit.java new file mode 100644 index 0000000..ecea7dc --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/broadcast/SideDeposit.java @@ -0,0 +1,47 @@ +package com.binance.dex.api.client.domain.broadcast; + +import java.util.List; + +import com.binance.dex.api.client.encoding.message.Token; +/** + * + * Created by fletcher on 2019/5/13. + */ +public class SideDeposit { + + private Long proposalId; + private String depositer; + private List amount; + private String sideChainId; + + public String getSideChainId() { + return sideChainId; + } + + public void setSideChainId(String sideChainId) { + this.sideChainId = sideChainId; + } + public Long getProposalId() { + return proposalId; + } + + public void setProposalId(Long proposalId) { + this.proposalId = proposalId; + } + + public String getDepositer() { + return depositer; + } + + public void setDepositer(String depositer) { + this.depositer = depositer; + } + + public List getAmount() { + return amount; + } + + public void setAmount(List amount) { + this.amount = amount; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/broadcast/SideSubmitProposal.java b/src/main/java/com/binance/dex/api/client/domain/broadcast/SideSubmitProposal.java new file mode 100644 index 0000000..919850d --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/broadcast/SideSubmitProposal.java @@ -0,0 +1,85 @@ +package com.binance.dex.api.client.domain.broadcast; + +import java.util.List; + +import com.binance.dex.api.client.domain.ProposalType; +import com.binance.dex.api.client.encoding.message.Token; + +public class SideSubmitProposal { + private String title; + private String description; + private ProposalType proposalType; + private String proposer; + private List initDeposit; + private Long votingPeriod; + private String sideChainId; + + public String getSideChainId() { + return sideChainId; + } + + public void setSideChainId(String sideChainId) { + this.sideChainId = sideChainId; + } + + public String getTitle() { + return title; + } + + public void setTitle(String title) { + this.title = title; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + public ProposalType getProposalType() { + return proposalType; + } + + public void setProposalType(ProposalType proposalType) { + this.proposalType = proposalType; + } + + public String getProposer() { + return proposer; + } + + public void setProposer(String proposer) { + this.proposer = proposer; + } + + public List getInitDeposit() { + return initDeposit; + } + + public void setInitDeposit(List initDeposit) { + this.initDeposit = initDeposit; + } + + public Long getVotingPeriod() { + return votingPeriod; + } + + public void setVotingPeriod(Long votingPeriod) { + this.votingPeriod = votingPeriod; + } + + @Override + public String toString() { + return "SubmitProposal{" + + "title='" + title + '\'' + + ", description='" + description + '\'' + + ", proposalType=" + proposalType + + ", proposer='" + proposer + '\'' + + ", initDeposit=" + initDeposit + + ", votingPeriod=" + votingPeriod + + ", sideChainId=" + sideChainId + + '}'; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/broadcast/SideVote.java b/src/main/java/com/binance/dex/api/client/domain/broadcast/SideVote.java new file mode 100644 index 0000000..c4e36f5 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/broadcast/SideVote.java @@ -0,0 +1,54 @@ +package com.binance.dex.api.client.domain.broadcast; + +public class SideVote { + + private Long proposalId; + + private Integer option; + + private String voter; + + private String sideChainId; + + public String getSideChainId() { + return sideChainId; + } + + public void setSideChainId(String sideChainId) { + this.sideChainId = sideChainId; + } + + public Long getProposalId() { + return proposalId; + } + + public void setProposalId(Long proposalId) { + this.proposalId = proposalId; + } + + public Integer getOption() { + return option; + } + + public void setOption(Integer option) { + this.option = option; + } + + public String getVoter() { + return voter; + } + + public void setVoter(String voter) { + this.voter = voter; + } + + @Override + public String toString() { + return "Vote{" + + "proposalId=" + proposalId + + ", option=" + option + + ", sideChainId=" + sideChainId + + ", voter='" + voter + '\'' + + '}'; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java b/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java index 532fb26..b151187 100644 --- a/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java +++ b/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java @@ -7,11 +7,14 @@ public enum TxType { UNFREEZE_TOKEN, TRANSFER, VOTE, + SIDE_VOTE, ISSUE, BURN, MINT, SUBMIT_PROPOSAL, + SIDE_SUBMIT_PROPOSAL, DEPOSIT, + SIDE_DEPOSIT, CREATE_VALIDATOR, REMOVE_VALIDATOR, LISTING, diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java b/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java index afbc2da..ff9224e 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java @@ -17,11 +17,14 @@ public enum MessageType { PubKey("EB5AE987"), StdTx("F0625DEE"), Vote("A1CADD36"), + SideVote("E26BA13D"), Issue("17EFAB80"), Burn("7ED2D2A0"), Mint("467E0829"), SubmitProposal("B42D614E"), + SideSubmitProposal("4ACBF03C"), Deposit("A18A56E5"), + SideDeposit("140F2DB4"), CreateValidator("DB6A19FD"), RemoveValidator("C1AFE85F"), Listing("B41DE13F"), diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/SideVoteMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/SideVoteMessage.java new file mode 100644 index 0000000..11b0f6a --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/SideVoteMessage.java @@ -0,0 +1,67 @@ +package com.binance.dex.api.client.encoding.message; + +import com.binance.dex.api.client.BinanceDexConstants; +import com.binance.dex.api.client.encoding.VoteOptionSerializer; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.fasterxml.jackson.databind.ser.std.ToStringSerializer; +import org.apache.commons.lang3.builder.ToStringBuilder; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class SideVoteMessage implements BinanceDexTransactionMessage { + + @JsonProperty("proposal_id") + @JsonSerialize(using = ToStringSerializer.class) + private Long proposalId; + private String voter; + @JsonSerialize(using = VoteOptionSerializer.class) + private Integer option; + @JsonProperty("side_chain_id") + private String sideChainId; + + public Long getProposalId() { + return proposalId; + } + + public void setProposalId(Long proposalId) { + this.proposalId = proposalId; + } + + public Integer getOption() { + return option; + } + + public void setOption(Integer option) { + this.option = option; + } + + public String getVoter() { + return voter; + } + + public void setVoter(String voter) { + this.voter = voter; + } + + public String getSideChainId() { + return sideChainId; + } + + public void setSideChainId(String sideChainId) { + this.sideChainId = sideChainId; + } + + @Override + public String toString() { + return new ToStringBuilder(this, BinanceDexConstants.BINANCE_DEX_TO_STRING_STYLE) + .append("proposalId", proposalId) + .append("option", option) + .append("sideChainId",sideChainId) + .toString(); + } + + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/TransactionRequestAssembler.java b/src/main/java/com/binance/dex/api/client/encoding/message/TransactionRequestAssembler.java index 2f05283..16b134e 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/TransactionRequestAssembler.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/TransactionRequestAssembler.java @@ -150,6 +150,16 @@ VoteMessage createVoteMessage(Vote vote){ return voteMessage; } + @VisibleForTesting + SideVoteMessage createSideVoteMessage(SideVote vote){ + SideVoteMessage voteMessage = new SideVoteMessage(); + voteMessage.setProposalId(vote.getProposalId()); + voteMessage.setOption(vote.getOption()); + voteMessage.setVoter(wallet.getAddress()); + voteMessage.setSideChainId(vote.getSideChainId()); + return voteMessage; + } + @VisibleForTesting byte[] encodeNewOrderMessage(NewOrderMessage newOrder) throws IOException { @@ -177,6 +187,18 @@ byte[] encodeVoteMessage(VoteMessage voteMessage) return EncodeUtils.aminoWrap(proto.toByteArray(), MessageType.Vote.getTypePrefixBytes(), false); } + @VisibleForTesting + byte[] encodeSideVoteMessage(SideVoteMessage voteMessage) + throws IOException { + com.binance.dex.api.proto.SideVote proto = com.binance.dex.api.proto.SideVote.newBuilder() + .setVoter(ByteString.copyFrom(wallet.getAddressBytes())) + .setProposalId(voteMessage.getProposalId()) + .setOption(voteMessage.getOption()) + .setSideChainId(voteMessage.getSideChainId()) + .build(); + return EncodeUtils.aminoWrap(proto.toByteArray(), MessageType.SideVote.getTypePrefixBytes(), false); + } + public RequestBody buildNewOrder(com.binance.dex.api.client.domain.broadcast.NewOrder newOrder) throws IOException, NoSuchAlgorithmException { return createRequestBody(buildNewOrderPayload(newOrder)); @@ -203,6 +225,18 @@ public String buildVotePayload(Vote vote) throws IOException, NoSuchAlgorithmExc return EncodeUtils.bytesToHex(stdTx); } + public RequestBody buildSideVote(SideVote vote) throws IOException, NoSuchAlgorithmException { + return createRequestBody(buildSideVotePayload(vote)); + } + + public String buildSideVotePayload(SideVote vote) throws IOException, NoSuchAlgorithmException { + SideVoteMessage msgBean = createSideVoteMessage(vote); + byte[] msg = encodeSideVoteMessage(msgBean); + byte[] signature = encodeSignature(sign(msgBean)); + byte[] stdTx = encodeStdTx(msg, signature); + return EncodeUtils.bytesToHex(stdTx); + } + @VisibleForTesting CancelOrderMessage createCancelOrderMessage( com.binance.dex.api.client.domain.broadcast.CancelOrder cancelOrder) { diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QuerySideProposal.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QuerySideProposal.java new file mode 100644 index 0000000..b6c411b --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QuerySideProposal.java @@ -0,0 +1,33 @@ +package com.binance.dex.api.client.encoding.message.sidechain.query; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class QuerySideProposal extends BaseQueryParams { + + @JsonProperty(value = "ProposalID") + private String proposalID; + + public QuerySideProposal() { + } + + public String getProposalID() { + return proposalID; + } + + public void setProposalID(String proposalID) { + this.proposalID = proposalID; + } + + public String getSideChainId() { + return sideChainId; + } + + public void setSideChainId(String sideChainId) { + this.sideChainId = sideChainId; + } + +} diff --git a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java index c1875a8..e9a9af4 100644 --- a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java +++ b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java @@ -3,6 +3,7 @@ import com.binance.dex.api.client.*; import com.binance.dex.api.client.domain.*; import com.binance.dex.api.client.domain.bridge.TransferIn; +import com.binance.dex.api.client.domain.broadcast.SideVote; import com.binance.dex.api.client.domain.oracle.Prophecy; import com.binance.dex.api.client.domain.StakeValidator; import com.binance.dex.api.client.domain.stake.Pool; @@ -13,10 +14,8 @@ import com.binance.dex.api.client.encoding.Crypto; import com.binance.dex.api.client.encoding.EncodeUtils; import com.binance.dex.api.client.encoding.message.TransactionRequestAssembler; -import com.binance.dex.api.client.impl.node.NodeQueryDelegateOracle; -import com.binance.dex.api.client.impl.node.NodeQueryDelegateSideChainStaking; -import com.binance.dex.api.client.impl.node.NodeTxDelegateBridge; -import com.binance.dex.api.client.impl.node.NodeTxDelegateSideChainStaking; +import com.binance.dex.api.client.encoding.message.sidechain.query.QuerySideProposal; +import com.binance.dex.api.client.impl.node.*; import com.binance.dex.api.proto.*; import com.binance.dex.api.proto.Token; import com.google.common.collect.Lists; @@ -278,6 +277,31 @@ public Proposal getProposalById(String proposalId) { } } + @Override + public Proposal getSideProposalById(String proposalId, String sideChainId) { + try { + QuerySideProposal params = new QuerySideProposal(); + params.setSideChainId(sideChainId); + params.setProposalID(proposalId); + + byte[] paramsBytes = EncodeUtils.toJsonEncodeBytes(params); + String requestData = "0x" + Hex.toHexString(paramsBytes); + JsonRpcResponse rpcResponse = BinanceDexApiClientGenerator.executeSync(binanceDexNodeApi.getProposalById(requestData)); + checkRpcResult(rpcResponse); + ABCIQueryResult.Response response = rpcResponse.getResult().getResponse(); + if (response.getCode() != null) { + BinanceDexApiError binanceDexApiError = new BinanceDexApiError(); + binanceDexApiError.setCode(response.getCode()); + binanceDexApiError.setMessage(response.getLog()); + throw new BinanceDexApiException(binanceDexApiError); + } + String proposalJson = new String(response.getValue()); + return EncodeUtils.toObjectFromJsonString(proposalJson, Proposal.class); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + @Override public List transfer(Transfer transfer, Wallet wallet, TransactionOption options, boolean sync) @@ -465,6 +489,20 @@ public long getAllSideChainValidatorsCount(String sideChainId, boolean jailInvol return sideChainQueryDelegate.queryAllSideChainValidatorsCount(sideChainId, jailInvolved); } + @Override + public List sideVote(SideVote vote, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException{ + synchronized (wallet) { + wallet.ensureWalletIsReady(this); + TransactionRequestAssembler assembler = new TransactionRequestAssembler(wallet, options); + String requestPayload = "0x" + assembler.buildSideVotePayload(vote); + if (sync) { + return syncBroadcast(requestPayload, wallet); + } else { + return asyncBroadcast(requestPayload, wallet); + } + } + } + @Override public List transferIn(long sequence, TransferIn transferIn, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { synchronized (wallet) { diff --git a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiRestClientImpl.java b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiRestClientImpl.java index 081d0e2..b3a0f2f 100644 --- a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiRestClientImpl.java +++ b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiRestClientImpl.java @@ -195,6 +195,14 @@ public List vote(Vote vote, Wallet wallet, TransactionOptio return broadcast(requestBody,sync,wallet); } + @Override + public List sideVote(SideVote vote, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + wallet.ensureWalletIsReady(this); + TransactionRequestAssembler assembler = new TransactionRequestAssembler(wallet, options); + RequestBody requestBody = assembler.buildSideVote(vote); + return broadcast(requestBody,sync,wallet); + } + public List cancelOrder(CancelOrder cancelOrder, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { wallet.ensureWalletIsReady(this); diff --git a/src/main/proto/dex.proto b/src/main/proto/dex.proto index 2fe5664..a984256 100644 --- a/src/main/proto/dex.proto +++ b/src/main/proto/dex.proto @@ -102,6 +102,14 @@ message Vote { int64 option = 3; // option from OptionSet chosen by the voter, } +message SideVote { + // 0xE26BA13D // hardcoded, object type prefix in 4 bytes + int64 proposal_id = 1; // ID of the proposal + bytes voter = 2; // address of the voter + int64 option = 3; // option from OptionSet chosen by the voter, + string side_chain_id = 4; +} + message Token { string denom = 1; int64 amount = 2; @@ -224,6 +232,17 @@ message SubmitProposal { int64 voting_period = 6; } +message SideSubmitProposal { + // 0x4ACBF03C + string title = 1; + string description = 2; + int64 proposal_type = 3; + bytes proposer = 4; + repeated Token initial_deposit = 5; + int64 voting_period = 6; + string side_chain_id = 7; +} + message Deposit { // 0xA18A56E5 int64 proposal_id = 1; @@ -231,6 +250,14 @@ message Deposit { repeated Token amount = 3; } +message SideDeposit { + // 0x140F2DB4 + int64 proposal_id = 1; + bytes depositer = 2; + repeated Token amount = 3; + string side_chain_id = 4; +} + message Description { string moniker = 1; string identity = 2; diff --git a/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java b/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java index 920ec61..0290996 100644 --- a/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java +++ b/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java @@ -205,9 +205,9 @@ public void testNodeInfo() { @Test public void testGetTransaction() { - Transaction transaction = binanceDexNodeApi.getTransaction("A1D07086EC08E983A47157FEACC1CF42179C37FCCDD56E7A4460CD1E4C82E51F"); + Transaction transaction = binanceDexNodeApi.getTransaction("8B13490FB57C4650CE68E09E51C768D76A15B00FE5E5898D9453EF9B7162DB82"); Assert.assertNotNull(transaction); - Assert.assertEquals("A1D07086EC08E983A47157FEACC1CF42179C37FCCDD56E7A4460CD1E4C82E51F", transaction.getHash()); + Assert.assertEquals("8B13490FB57C4650CE68E09E51C768D76A15B00FE5E5898D9453EF9B7162DB82", transaction.getHash()); Assert.assertEquals(0, transaction.getCode().intValue()); } @@ -251,4 +251,10 @@ public void testGetProposalById(){ Proposal proposal = binanceDexNodeApi.getProposalById("1"); Assert.assertEquals("1",proposal.getValue().getProposalId()); } + + @Test + public void testGetSideProposalById(){ + Proposal proposal = binanceDexNodeApi.getSideProposalById("4", "rialto"); + Assert.assertEquals("4",proposal.getValue().getProposalId()); + } } diff --git a/src/test/java/com/binance/dex/api/client/examples/SideVoteExample.java b/src/test/java/com/binance/dex/api/client/examples/SideVoteExample.java new file mode 100644 index 0000000..c667dcc --- /dev/null +++ b/src/test/java/com/binance/dex/api/client/examples/SideVoteExample.java @@ -0,0 +1,31 @@ +package com.binance.dex.api.client.examples; + +import java.io.IOException; +import java.util.List; + +import com.binance.dex.api.client.*; +import com.binance.dex.api.client.domain.TransactionMetadata; +import com.binance.dex.api.client.domain.broadcast.SideVote; +import com.binance.dex.api.client.domain.broadcast.TransactionOption; + +public class SideVoteExample { + + public static void main(String[] args) throws IOException { + Wallet wallet = Wallet.createRandomWallet(BinanceDexEnvironment.TEST_NET); + BinanceDexApiNodeClient binanceDexNodeApi = BinanceDexApiClientFactory.newInstance().newNodeRpcClient(BinanceDexEnvironment.TEST_NET.getNodeUrl(),BinanceDexEnvironment.TEST_NET.getHrp(), BinanceDexEnvironment.TEST_NET.getValHrp()); + + + TransactionOption options = TransactionOption.DEFAULT_INSTANCE; + SideVote vote = new SideVote(); + vote.setOption(1); + vote.setProposalId(2L); + vote.setSideChainId("rialto"); + try{ + List resp = binanceDexNodeApi.sideVote(vote,wallet,options,true); + System.out.println(resp.get(0)); + }catch (Exception e){ + e.printStackTrace(); + } + } + +} From dc71547c6bd3a1dc152db6798c87c7ea9a093954 Mon Sep 17 00:00:00 2001 From: fletcher142 <42368365+fletcher142@users.noreply.github.com> Date: Fri, 3 Jul 2020 14:18:49 +0800 Subject: [PATCH 12/52] claim/unbind refactor (#89) * claim/unbind refactor * rename unbind --- .../api/client/BinanceDexApiNodeClient.java | 4 +- .../dex/api/client/TransactionConverter.java | 27 +++++- .../dex/api/client/domain/bridge/Unbind.java | 32 ++++++++ .../api/client/domain/broadcast/TxType.java | 1 + .../api/client/domain/jsonrpc/TxResult.java | 11 +++ .../api/client/domain/oracle/ClaimMsg.java | 26 +++--- .../api/client/encoding/amino/WireType.java | 2 + .../client/encoding/message/MessageType.java | 1 + .../message/bridge/ClaimMsgMessage.java | 51 ++++++------ .../message/bridge/UnbindMsgMessage.java | 82 +++++++++++++++++++ .../impl/BinanceDexApiNodeClientImpl.java | 12 ++- .../impl/node/NodeTxDelegateBridge.java | 21 +++-- .../dex/api/client/encoding/AminoTest.java | 14 +++- .../client/examples/BridgeNodeExample.java | 23 +++++- 14 files changed, 251 insertions(+), 56 deletions(-) create mode 100644 src/main/java/com/binance/dex/api/client/domain/bridge/Unbind.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/bridge/UnbindMsgMessage.java diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java b/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java index c3dfcce..236aab0 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java @@ -199,7 +199,7 @@ default List unfreeze(TokenUnfreeze unfreeze, Wallet wallet long getAllSideChainValidatorsCount(String sideChainId, boolean jailInvolved) throws IOException; - List claim(int claimType, String claim, long sequence, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; + List claim(int chainId, byte[] payload, long sequence, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; @Nullable Prophecy getProphecy(int claimType, long sequence) throws IOException; @@ -212,6 +212,8 @@ default List unfreeze(TokenUnfreeze unfreeze, Wallet wallet List bind(String symbol, long amount, String contractAddress, int contractDecimal, long expireTimeInSeconds, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; + List unBind(String symbol, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; + List updateTransferOut(long sequence, String refundAddress, com.binance.dex.api.client.encoding.message.Token amount, int refundReason, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; List updateBind(long sequence, String symbol, String contractAddress, int status, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; diff --git a/src/main/java/com/binance/dex/api/client/TransactionConverter.java b/src/main/java/com/binance/dex/api/client/TransactionConverter.java index 8751340..45b773d 100644 --- a/src/main/java/com/binance/dex/api/client/TransactionConverter.java +++ b/src/main/java/com/binance/dex/api/client/TransactionConverter.java @@ -3,6 +3,7 @@ import com.binance.dex.api.client.domain.*; import com.binance.dex.api.client.domain.bridge.Bind; import com.binance.dex.api.client.domain.bridge.TransferOut; +import com.binance.dex.api.client.domain.bridge.Unbind; import com.binance.dex.api.client.domain.broadcast.*; import com.binance.dex.api.client.domain.broadcast.Burn; import com.binance.dex.api.client.domain.broadcast.CancelOrder; @@ -37,6 +38,7 @@ import com.binance.dex.api.client.encoding.message.bridge.BindMsgMessage; import com.binance.dex.api.client.encoding.message.bridge.ClaimMsgMessage; import com.binance.dex.api.client.encoding.message.bridge.TransferOutMsgMessage; +import com.binance.dex.api.client.encoding.message.bridge.UnbindMsgMessage; import com.binance.dex.api.client.encoding.message.sidechain.transaction.*; import com.binance.dex.api.proto.*; import com.binance.dex.api.proto.TimeLock; @@ -210,6 +212,8 @@ public Transaction convert(byte[] bytes) { return convertTransferOutMsg(bytes); case Bind: return convertBindMsg(bytes); + case UnBind: + return convertUnBindMsg(bytes); case BscSubmitEvidence: return convertBscSubmitEvidence(bytes); case SideChainUnJail: @@ -300,6 +304,25 @@ private Transaction convertBindMsg(byte[] value) throws IOException { return transaction; } + private Transaction convertUnBindMsg(byte[] value) throws IOException { + byte[] raw = ByteUtil.cut(value, 4); + UnbindMsgMessage message = new UnbindMsgMessage(); + amino.decodeBare(raw, message); + + Unbind bind = new Unbind(); + if (message.getFrom() != null && message.getFrom().getRaw() != null) { + bind.setFrom(Crypto.encodeAddress(hrp, message.getFrom().getRaw())); + } + bind.setSymbol(message.getSymbol()); + + + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.UNBIND); + transaction.setRealTx(bind); + + return transaction; + } + private Transaction convertTransferOutMsg(byte[] value) throws IOException { byte[] raw = ByteUtil.cut(value, 4); TransferOutMsgMessage message = new TransferOutMsgMessage(); @@ -334,9 +357,9 @@ private Transaction convertClaimMsg(byte[] value) throws IOException { ClaimMsgMessage message = new ClaimMsgMessage(); amino.decodeBare(raw, message); ClaimMsg claimMsg = new ClaimMsg(); - claimMsg.setClaimType(message.getClaimType()); + claimMsg.setChainId(message.getChainId()); claimMsg.setSequence(message.getSequence()); - claimMsg.setClaim(message.getClaim()); + claimMsg.setPayload(message.getPayload()); if (message.getValidatorAddress().getRaw() != null) { claimMsg.setValidatorAddress(Crypto.encodeAddress(valHrp, message.getValidatorAddress().getRaw())); } diff --git a/src/main/java/com/binance/dex/api/client/domain/bridge/Unbind.java b/src/main/java/com/binance/dex/api/client/domain/bridge/Unbind.java new file mode 100644 index 0000000..f2cff44 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/bridge/Unbind.java @@ -0,0 +1,32 @@ +package com.binance.dex.api.client.domain.bridge; + +public class Unbind { + + private String from; + + private String symbol; + + public String getFrom() { + return from; + } + + public void setFrom(String from) { + this.from = from; + } + + public String getSymbol() { + return symbol; + } + + public void setSymbol(String symbol) { + this.symbol = symbol; + } + + @Override + public String toString() { + return "UnBind{" + + "from='" + from + '\'' + + ", symbol='" + symbol + '\'' + + '}'; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java b/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java index b151187..8b9b2f9 100644 --- a/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java +++ b/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java @@ -34,6 +34,7 @@ public enum TxType { CLAIM, TRANSFER_OUT, BIND, + UNBIND, BSC_SUBMIT_EVIDENCE, SIDECHAIN_UNJAIL } diff --git a/src/main/java/com/binance/dex/api/client/domain/jsonrpc/TxResult.java b/src/main/java/com/binance/dex/api/client/domain/jsonrpc/TxResult.java index 21cc36c..6ce5c0a 100644 --- a/src/main/java/com/binance/dex/api/client/domain/jsonrpc/TxResult.java +++ b/src/main/java/com/binance/dex/api/client/domain/jsonrpc/TxResult.java @@ -74,6 +74,9 @@ public void setValue(byte[] value) { } public static class Event{ + + private String type; + private List attributes; public List getAttributes() { @@ -83,6 +86,14 @@ public List getAttributes() { public void setAttributes(List attributes) { this.attributes = attributes; } + + public String getType() { + return type; + } + + public void setType(String type) { + this.type = type; + } } public static class Attribute{ diff --git a/src/main/java/com/binance/dex/api/client/domain/oracle/ClaimMsg.java b/src/main/java/com/binance/dex/api/client/domain/oracle/ClaimMsg.java index 0774a3f..81543c5 100644 --- a/src/main/java/com/binance/dex/api/client/domain/oracle/ClaimMsg.java +++ b/src/main/java/com/binance/dex/api/client/domain/oracle/ClaimMsg.java @@ -1,24 +1,26 @@ package com.binance.dex.api.client.domain.oracle; +import org.apache.commons.codec.binary.Hex; + /** * @author Fitz.Lu **/ public class ClaimMsg { - private int claimType; + private int chainId; private long sequence; - private String claim; + private byte[] payload; private String validatorAddress; - public int getClaimType() { - return claimType; + public int getChainId() { + return chainId; } - public void setClaimType(int claimType) { - this.claimType = claimType; + public void setChainId(int chainId) { + this.chainId = chainId; } public long getSequence() { @@ -29,12 +31,12 @@ public void setSequence(long sequence) { this.sequence = sequence; } - public String getClaim() { - return claim; + public byte[] getPayload() { + return payload; } - public void setClaim(String claim) { - this.claim = claim; + public void setPayload(byte[] payload) { + this.payload = payload; } public String getValidatorAddress() { @@ -48,9 +50,9 @@ public void setValidatorAddress(String validatorAddress) { @Override public String toString() { return "ClaimMsg{" + - "claimType=" + claimType + + "chainId=" + chainId + ", sequence=" + sequence + - ", claim='" + claim + '\'' + + ", payload='" + Hex.encodeHexString(payload) + '\'' + ", validatorAddress='" + validatorAddress + '\'' + '}'; } diff --git a/src/main/java/com/binance/dex/api/client/encoding/amino/WireType.java b/src/main/java/com/binance/dex/api/client/encoding/amino/WireType.java index da61b1a..9c0f885 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/amino/WireType.java +++ b/src/main/java/com/binance/dex/api/client/encoding/amino/WireType.java @@ -4,6 +4,7 @@ import com.binance.dex.api.client.encoding.message.bridge.BindMsgMessage; import com.binance.dex.api.client.encoding.message.bridge.ClaimMsgMessage; import com.binance.dex.api.client.encoding.message.bridge.TransferOutMsgMessage; +import com.binance.dex.api.client.encoding.message.bridge.UnbindMsgMessage; import com.binance.dex.api.client.encoding.message.sidechain.transaction.*; import org.bouncycastle.util.encoders.Hex; @@ -29,6 +30,7 @@ public class WireType { classToTypeName.put(TransferOutMsgMessage.class, "bridge/TransferOutMsg"); classToTypeName.put(BindMsgMessage.class, "bridge/BindMsg"); + classToTypeName.put(UnbindMsgMessage.class, "bridge/UnbindMsg"); classToTypeName.put(ClaimMsgMessage.class, "oracle/ClaimMsg"); } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java b/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java index ff9224e..7ce8abe 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java @@ -44,6 +44,7 @@ public enum MessageType { Claim("175A0521"), TransferOut("800819C0"), Bind("B9AE640C"), + UnBind("E9EEC508"), BscSubmitEvidence("A38F1399"), SideChainUnJail("5681EC54"); diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/ClaimMsgMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/ClaimMsgMessage.java index 28d3b5a..8548dd3 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/ClaimMsgMessage.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/ClaimMsgMessage.java @@ -9,7 +9,6 @@ import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.annotation.JsonPropertyOrder; import com.fasterxml.jackson.databind.annotation.JsonSerialize; -import org.apache.commons.lang3.StringUtils; import java.util.ArrayList; @@ -20,14 +19,14 @@ @JsonPropertyOrder(alphabetic = true) public class ClaimMsgMessage implements BinanceDexTransactionMessage, AminoSerializable { - @JsonProperty(value = "claim_type") - private int claimType; + @JsonProperty(value = "chain_id") + private int chainId; @JsonProperty(value = "sequence") private long sequence; - @JsonProperty(value = "claim") - private String claim; + @JsonProperty(value = "payload") + private byte[] payload; @JsonProperty(value = "validator_address") @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) @@ -36,19 +35,19 @@ public class ClaimMsgMessage implements BinanceDexTransactionMessage, AminoSeria public ClaimMsgMessage() { } - public ClaimMsgMessage(int claimType, long sequence, String claim, Bech32AddressValue validatorAddress) { - this.claimType = claimType; + public ClaimMsgMessage(int chainId, long sequence, byte[] payload, Bech32AddressValue validatorAddress) { + this.chainId = chainId; this.sequence = sequence; - this.claim = claim; + this.payload = payload; this.validatorAddress = validatorAddress; } - public int getClaimType() { - return claimType; + public int getChainId() { + return chainId; } - public void setClaimType(int claimType) { - this.claimType = claimType; + public void setChainId(int chainId) { + this.chainId = chainId; } public long getSequence() { @@ -59,12 +58,12 @@ public void setSequence(long sequence) { this.sequence = sequence; } - public String getClaim() { - return claim; + public byte[] getPayload() { + return payload; } - public void setClaim(String claim) { - this.claim = claim; + public void setPayload(byte[] payload) { + this.payload = payload; } public Bech32AddressValue getValidatorAddress() { @@ -77,14 +76,14 @@ public void setValidatorAddress(Bech32AddressValue validatorAddress) { @Override public void validateBasic() { - if (!ClaimTypes.IsValidClaimType(claimType)){ - throw new IllegalArgumentException(String.format("claim type %s does not exist, see class ClaimTypes", claimType)); + if (!ClaimTypes.IsValidClaimType(chainId)) { + throw new IllegalArgumentException(String.format("claim type %s does not exist, see class ClaimTypes", chainId)); } - if (sequence < 0){ + if (sequence < 0) { throw new IllegalArgumentException("sequence should not be less than 0"); } - if (StringUtils.isEmpty(claim)){ - throw new IllegalArgumentException("claim should not be empty"); + if (payload == null || payload.length == 0) { + throw new IllegalArgumentException("payload should not be empty"); } } @@ -96,10 +95,10 @@ public AminoSerializable newAminoMessage() { @Override public ArrayList> IterateFields() { return AminoField.newFieldsBuilder() - .addField(Integer.class, claimType, false) + .addField(Integer.class, chainId, false) .addField(Long.class, sequence, false) - .addField(String.class, claim, StringUtils.isEmpty(claim)) - .addField(Bech32AddressValue.class, validatorAddress, validatorAddress == null ||validatorAddress.isDefaultOrEmpty()) + .addField(byte[].class, payload, (payload == null || payload.length == 0)) + .addField(Bech32AddressValue.class, validatorAddress, validatorAddress == null || validatorAddress.isDefaultOrEmpty()) .build(); } @@ -107,13 +106,13 @@ public ArrayList> IterateFields() { public void setValueByFieldIndex(int fieldIndex, Object value) { switch (fieldIndex) { case 1: - claimType = ((int) value); + chainId = ((int) value); break; case 2: sequence = ((long) value); break; case 3: - claim = ((String) value); + payload = (byte[]) value; break; case 4: validatorAddress = (Bech32AddressValue) value; diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/UnbindMsgMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/UnbindMsgMessage.java new file mode 100644 index 0000000..d80dfd5 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/UnbindMsgMessage.java @@ -0,0 +1,82 @@ +package com.binance.dex.api.client.encoding.message.bridge; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.encoding.serializer.Bech32AddressValueToStringSerializer; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import org.apache.commons.lang3.StringUtils; + +import java.util.ArrayList; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class UnbindMsgMessage implements BinanceDexTransactionMessage, AminoSerializable { + + @JsonProperty(value = "from") + @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) + private Bech32AddressValue from; + + @JsonProperty(value = "symbol") + private String symbol; + + public UnbindMsgMessage() { + } + + public UnbindMsgMessage(Bech32AddressValue from, String symbol) { + this.from = from; + this.symbol = symbol; + } + + @Override + public AminoSerializable newAminoMessage() { + return new UnbindMsgMessage(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(Bech32AddressValue.class, from, from == null || from.isDefaultOrEmpty()) + .addField(String.class, symbol, StringUtils.isEmpty(symbol)) + .build(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + from = ((Bech32AddressValue) value); + break; + case 2: + symbol = ((String) value); + break; + } + } + + @Override + public void validateBasic() { + if (StringUtils.isEmpty(symbol)){ + throw new IllegalArgumentException("symbol should not be empty"); + } + } + + public Bech32AddressValue getFrom() { + return from; + } + + public void setFrom(Bech32AddressValue from) { + this.from = from; + } + + public String getSymbol() { + return symbol; + } + + public void setSymbol(String symbol) { + this.symbol = symbol; + } +} diff --git a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java index e9a9af4..b13156d 100644 --- a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java +++ b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java @@ -527,6 +527,14 @@ public List bind(String symbol, long amount, String contrac } } + @Override + public List unBind(String symbol, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + synchronized (wallet) { + wallet.ensureWalletIsReady(this); + return bridgeTxDelegate.unBind(symbol, wallet, options, sync); + } + } + @Override public List updateTransferOut(long sequence, String refundAddress, com.binance.dex.api.client.encoding.message.Token amount, int refundReason, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { synchronized (wallet) { @@ -544,10 +552,10 @@ public List updateBind(long sequence, String symbol, String } @Override - public List claim(int claimType, String claim, long sequence, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + public List claim(int chainId, byte[] payload, long sequence, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { synchronized (wallet) { wallet.ensureWalletIsReady(this); - return bridgeTxDelegate.claim(claimType, claim, sequence, wallet, options, sync); + return bridgeTxDelegate.claim(chainId, payload, sequence, wallet, options, sync); } } diff --git a/src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegateBridge.java b/src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegateBridge.java index d75748f..51d5bcb 100644 --- a/src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegateBridge.java +++ b/src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegateBridge.java @@ -25,20 +25,19 @@ public NodeTxDelegateBridge(BinanceDexNodeApi binanceDexNodeApi, String hrp, Str super(binanceDexNodeApi, hrp, valHrp); } - public List claim(int claimType, String claim, long sequence, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + public List claim(int chainId, byte[] payload, long sequence, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { ClaimMsgMessage message = new ClaimMsgMessage(); - message.setClaimType(claimType); + message.setChainId(chainId); message.setSequence(sequence); - message.setClaim(claim); + message.setPayload(payload); message.setValidatorAddress(Bech32AddressValue.fromBech32String(wallet.getAddress())); - return broadcast(message, wallet, options, sync); } public List transferIn(long sequence, TransferIn transferIn, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { TransferInClaimMessage message = convert(transferIn); String claim = EncodeUtils.getObjectMapper().writeValueAsString(message); - ClaimMsgMessage claimMsg = new ClaimMsgMessage(ClaimTypes.ClaimTypeTransferIn, sequence, claim, Bech32AddressValue.fromBech32String(wallet.getAddress())); + ClaimMsgMessage claimMsg = new ClaimMsgMessage(ClaimTypes.ClaimTypeTransferIn, sequence, claim.getBytes(), Bech32AddressValue.fromBech32String(wallet.getAddress())); return broadcast(claimMsg, wallet, options, sync); } @@ -65,6 +64,14 @@ public List bind(String symbol, long amount, String contrac return broadcast(message, wallet, options, sync); } + public List unBind(String symbol, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + UnbindMsgMessage message = new UnbindMsgMessage(); + message.setFrom(Bech32AddressValue.fromBech32String(wallet.getAddress())); + message.setSymbol(symbol); + + return broadcast(message, wallet, options, sync); + } + public List updateTransferOut(long sequence, String refundAddress, Token amount, int refundReason, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { UpdateTransferOutClaimMessage message = new UpdateTransferOutClaimMessage(); message.setAmount(convert(amount)); @@ -72,7 +79,7 @@ public List updateTransferOut(long sequence, String refundA message.setRefundReason(refundReason); ClaimMsgMessage claimMsg = new ClaimMsgMessage(ClaimTypes.ClaimTypeUpdateTransferOut, sequence, - EncodeUtils.getObjectMapper().writeValueAsString(message), Bech32AddressValue.fromBech32String(wallet.getAddress())); + EncodeUtils.getObjectMapper().writeValueAsString(message).getBytes(), Bech32AddressValue.fromBech32String(wallet.getAddress())); return broadcast(claimMsg, wallet, options, sync); } @@ -84,7 +91,7 @@ public List updateBind(long sequence, String symbol, String message.setContractAddress(EthAddressValue.from(contractAddress)); ClaimMsgMessage claimMsg = new ClaimMsgMessage(ClaimTypes.ClaimTypeUpdateBind, sequence, - EncodeUtils.getObjectMapper().writeValueAsString(message), Bech32AddressValue.fromBech32String(wallet.getAddress())); + EncodeUtils.getObjectMapper().writeValueAsString(message).getBytes(), Bech32AddressValue.fromBech32String(wallet.getAddress())); return broadcast(claimMsg, wallet, options, sync); } diff --git a/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java b/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java index aa854c7..7384156 100644 --- a/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java +++ b/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java @@ -43,8 +43,8 @@ public void testDecodeRedelegation() throws IOException { @Test public void testClaim() throws IOException { ClaimMsgMessage message = new ClaimMsgMessage(); - message.setClaimType(ClaimTypes.ClaimTypeTransferIn); - message.setClaim("claim content"); + message.setChainId(ClaimTypes.ClaimTypeTransferIn); + message.setPayload("claim content".getBytes()); message.setSequence(1); message.setValidatorAddress(Bech32AddressValue.fromBech32String("bva1337r5pk3r6kvs4a8kc3u5yhdjc79c5lg78343t")); byte[] data = amino.encode(message, MessageType.Claim.getTypePrefixBytes(), false); @@ -78,6 +78,16 @@ public void testBind() throws IOException { Assert.assertNotNull(transaction.getRealTx()); } + @Test + public void testUnBind() throws IOException { + UnbindMsgMessage message = new UnbindMsgMessage(); + message.setFrom(Bech32AddressValue.fromBech32StringWithNewHrp("bva1337r5pk3r6kvs4a8kc3u5yhdjc79c5lg78343t", "bnb")); + message.setSymbol("BNB"); + byte[] data = amino.encode(message, MessageType.UnBind.getTypePrefixBytes(), false); + Transaction transaction = transactionConverter.convert(data); + Assert.assertNotNull(transaction.getRealTx()); + } + @Test public void testCreateSideChainValidator() throws IOException { CreateSideChainValidator createSideChainValidator = new CreateSideChainValidator(); diff --git a/src/test/java/com/binance/dex/api/client/examples/BridgeNodeExample.java b/src/test/java/com/binance/dex/api/client/examples/BridgeNodeExample.java index d9c4377..9ee72c0 100644 --- a/src/test/java/com/binance/dex/api/client/examples/BridgeNodeExample.java +++ b/src/test/java/com/binance/dex/api/client/examples/BridgeNodeExample.java @@ -8,6 +8,7 @@ import com.binance.dex.api.client.domain.bridge.TransferIn; import com.binance.dex.api.client.domain.broadcast.TransactionOption; import com.binance.dex.api.client.domain.oracle.Prophecy; +import com.binance.dex.api.client.encoding.EncodeUtils; import com.binance.dex.api.client.encoding.message.Token; import com.binance.dex.api.client.encoding.message.bridge.BindStatus; import com.binance.dex.api.client.encoding.message.bridge.ClaimTypes; @@ -19,6 +20,7 @@ import java.io.IOException; import java.security.NoSuchAlgorithmException; import java.util.ArrayList; +import java.util.Arrays; import java.util.List; /** @@ -27,11 +29,13 @@ public class BridgeNodeExample { private BinanceDexApiNodeClient nodeClient = null; - private final Wallet wallet = new Wallet("bce1c934173e84cb4a0abf06b371f7568d3c4686da8f3ea7e1e8d230ae681920", BinanceDexEnvironment.TEST_NET); + private Wallet wallet = null; @Before - public void setup() { - nodeClient = BinanceDexApiClientFactory.newInstance().newNodeRpcClient(BinanceDexEnvironment.TEST_NET.getNodeUrl(),BinanceDexEnvironment.TEST_NET.getHrp(), BinanceDexEnvironment.TEST_NET.getValHrp()); + public void setup() throws IOException { + nodeClient = BinanceDexApiClientFactory.newInstance().newNodeRpcClient("http://dex-qa-s1-bsc-dev-validator-alb-501442930.ap-northeast-1.elb.amazonaws.com:27147",BinanceDexEnvironment.TEST_NET.getHrp(), BinanceDexEnvironment.TEST_NET.getValHrp()); + String mnemonic = "ten spring excite fluid pizza amused goat equal language cinnamon change drive alien second table onion obscure culture void science renew scrub capable wet"; + wallet = Wallet.createWalletFromMnemonicCode(Arrays.asList(mnemonic.split(" ")), BinanceDexEnvironment.TEST_NET); } @Test @@ -91,6 +95,16 @@ public void bind() throws IOException, NoSuchAlgorithmException { Assert.assertEquals(1, results.size()); } + @Test + public void unBind() throws IOException, NoSuchAlgorithmException { + String symbol = "ABC-196"; + TransactionOption options = new TransactionOption("", 0, null); + List results = nodeClient.unBind(symbol, wallet, options, true); + System.out.println(EncodeUtils.toJsonStringSortKeys(results)); + Assert.assertEquals(1, results.size()); + Assert.assertTrue(results.get(0).isOk()); + } + @Test public void updateTransferOut() throws IOException, NoSuchAlgorithmException { long sequence = nodeClient.getCurrentSequence(ClaimTypes.ClaimTypeUpdateTransferOut); @@ -120,8 +134,9 @@ public void updateBind() throws IOException, NoSuchAlgorithmException { @Test public void claim() throws IOException, NoSuchAlgorithmException { TransactionOption options = new TransactionOption("", 0, null); - List results = nodeClient.claim(ClaimTypes.ClaimTypeUpdateBind, "claim message", 1, wallet, options, true); + List results = nodeClient.claim(2, "test claim message message message message message".getBytes(), 0, wallet, options, true); Assert.assertEquals(1, results.size()); + Assert.assertTrue(results.get(0).isOk()); } @Test From 764e27ee2e3744576de1e67ee913afd17e387fae Mon Sep 17 00:00:00 2001 From: "fletcher.fan" Date: Tue, 7 Jul 2020 12:08:15 +0800 Subject: [PATCH 13/52] json serializer refactor --- .../message/bridge/BindMsgMessage.java | 5 ----- .../message/bridge/ClaimMsgMessage.java | 3 --- .../message/bridge/TransferOutMsgMessage.java | 5 ----- .../message/bridge/UnbindMsgMessage.java | 3 --- .../bridge/UpdateBindClaimMessage.java | 3 --- .../bridge/UpdateTransferOutClaimMessage.java | 3 --- .../message/common/Bech32AddressValue.java | 4 +++- .../message/common/EthAddressValue.java | 3 +++ .../sidechain/query/QueryValidatorParams.java | 3 --- .../CreateSideChainValidatorMessage.java | 4 ---- .../EditSideChainValidatorMessage.java | 2 -- .../transaction/SideChainDelegateMessage.java | 4 ---- .../SideChainRedelegateMessage.java | 5 ----- .../SideChainUndelegateMessage.java | 4 ---- .../Bech32AddressValueToStringSerializer.java | 21 ++++++++++++++++--- .../EthAddressValueToStringSerializer.java | 12 ++++++++++- 16 files changed, 35 insertions(+), 49 deletions(-) diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/BindMsgMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/BindMsgMessage.java index 0a3220b..c9eb880 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/BindMsgMessage.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/BindMsgMessage.java @@ -5,12 +5,9 @@ import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; import com.binance.dex.api.client.encoding.message.common.EthAddressValue; -import com.binance.dex.api.client.encoding.serializer.Bech32AddressValueToStringSerializer; -import com.binance.dex.api.client.encoding.serializer.EthAddressValueToStringSerializer; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.annotation.JsonPropertyOrder; -import com.fasterxml.jackson.databind.annotation.JsonSerialize; import org.apache.commons.lang3.StringUtils; import java.util.ArrayList; @@ -23,7 +20,6 @@ public class BindMsgMessage implements BinanceDexTransactionMessage, AminoSerializable { @JsonProperty(value = "from") - @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) private Bech32AddressValue from; @JsonProperty(value = "symbol") @@ -33,7 +29,6 @@ public class BindMsgMessage implements BinanceDexTransactionMessage, AminoSerial private long amount; @JsonProperty(value = "contract_address") - @JsonSerialize(using = EthAddressValueToStringSerializer.class) private EthAddressValue contractAddress; @JsonProperty(value = "contract_decimals") diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/ClaimMsgMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/ClaimMsgMessage.java index 8548dd3..ddecd3c 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/ClaimMsgMessage.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/ClaimMsgMessage.java @@ -4,11 +4,9 @@ import com.binance.dex.api.client.encoding.amino.AminoSerializable; import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; -import com.binance.dex.api.client.encoding.serializer.Bech32AddressValueToStringSerializer; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.annotation.JsonPropertyOrder; -import com.fasterxml.jackson.databind.annotation.JsonSerialize; import java.util.ArrayList; @@ -29,7 +27,6 @@ public class ClaimMsgMessage implements BinanceDexTransactionMessage, AminoSeria private byte[] payload; @JsonProperty(value = "validator_address") - @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) private Bech32AddressValue validatorAddress; public ClaimMsgMessage() { diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/TransferOutMsgMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/TransferOutMsgMessage.java index cf3cd84..c512793 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/TransferOutMsgMessage.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/TransferOutMsgMessage.java @@ -6,12 +6,9 @@ import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; import com.binance.dex.api.client.encoding.message.common.CoinValue; import com.binance.dex.api.client.encoding.message.common.EthAddressValue; -import com.binance.dex.api.client.encoding.serializer.Bech32AddressValueToStringSerializer; -import com.binance.dex.api.client.encoding.serializer.EthAddressValueToStringSerializer; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.annotation.JsonPropertyOrder; -import com.fasterxml.jackson.databind.annotation.JsonSerialize; import java.util.ArrayList; @@ -23,11 +20,9 @@ public class TransferOutMsgMessage implements BinanceDexTransactionMessage, AminoSerializable { @JsonProperty(value = "from") - @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) private Bech32AddressValue from; @JsonProperty(value = "to") - @JsonSerialize(using = EthAddressValueToStringSerializer.class) private EthAddressValue toAddress; @JsonProperty(value = "amount") diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/UnbindMsgMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/UnbindMsgMessage.java index d80dfd5..891947f 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/UnbindMsgMessage.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/UnbindMsgMessage.java @@ -4,11 +4,9 @@ import com.binance.dex.api.client.encoding.amino.AminoSerializable; import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; -import com.binance.dex.api.client.encoding.serializer.Bech32AddressValueToStringSerializer; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.annotation.JsonPropertyOrder; -import com.fasterxml.jackson.databind.annotation.JsonSerialize; import org.apache.commons.lang3.StringUtils; import java.util.ArrayList; @@ -18,7 +16,6 @@ public class UnbindMsgMessage implements BinanceDexTransactionMessage, AminoSerializable { @JsonProperty(value = "from") - @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) private Bech32AddressValue from; @JsonProperty(value = "symbol") diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/UpdateBindClaimMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/UpdateBindClaimMessage.java index 95e4dbb..6a2952e 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/UpdateBindClaimMessage.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/UpdateBindClaimMessage.java @@ -4,11 +4,9 @@ import com.binance.dex.api.client.encoding.amino.AminoSerializable; import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; import com.binance.dex.api.client.encoding.message.common.EthAddressValue; -import com.binance.dex.api.client.encoding.serializer.EthAddressValueToStringSerializer; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.annotation.JsonPropertyOrder; -import com.fasterxml.jackson.databind.annotation.JsonSerialize; import org.apache.commons.lang3.StringUtils; import java.util.ArrayList; @@ -27,7 +25,6 @@ public class UpdateBindClaimMessage implements BinanceDexTransactionMessage, Ami private String symbol; @JsonProperty(value = "contract_address") - @JsonSerialize(using = EthAddressValueToStringSerializer.class) private EthAddressValue contractAddress; public int getStatus() { diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/UpdateTransferOutClaimMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/UpdateTransferOutClaimMessage.java index 3b7734b..17c549b 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/bridge/UpdateTransferOutClaimMessage.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/bridge/UpdateTransferOutClaimMessage.java @@ -5,11 +5,9 @@ import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; import com.binance.dex.api.client.encoding.message.common.CoinValue; -import com.binance.dex.api.client.encoding.serializer.Bech32AddressValueToStringSerializer; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.annotation.JsonPropertyOrder; -import com.fasterxml.jackson.databind.annotation.JsonSerialize; import java.util.ArrayList; @@ -21,7 +19,6 @@ public class UpdateTransferOutClaimMessage implements BinanceDexTransactionMessage, AminoSerializable { @JsonProperty(value = "refund_address") - @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) private Bech32AddressValue refundAddress; @JsonProperty(value = "amount") diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/common/Bech32AddressValue.java b/src/main/java/com/binance/dex/api/client/encoding/message/common/Bech32AddressValue.java index fb1e5c5..e185e68 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/common/Bech32AddressValue.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/common/Bech32AddressValue.java @@ -5,6 +5,8 @@ import com.binance.dex.api.client.encoding.Crypto; import com.binance.dex.api.client.encoding.amino.AminoCustomSerialized; import com.binance.dex.api.client.encoding.amino.WireType; +import com.binance.dex.api.client.encoding.serializer.Bech32AddressValueToStringSerializer; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; import com.google.protobuf.CodedInputStream; import com.google.protobuf.CodedOutputStream; @@ -13,6 +15,7 @@ /** * @author Fitz.Lu **/ +@JsonSerialize(using = Bech32AddressValueToStringSerializer.class) public class Bech32AddressValue implements AminoCustomSerialized { private String hrp; @@ -90,5 +93,4 @@ public int getSerializedSize() { return CodedOutputStream.computeByteArraySizeNoTag(raw); } } - } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/common/EthAddressValue.java b/src/main/java/com/binance/dex/api/client/encoding/message/common/EthAddressValue.java index 071f2be..c580e74 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/common/EthAddressValue.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/common/EthAddressValue.java @@ -2,6 +2,8 @@ import com.binance.dex.api.client.encoding.amino.AminoCustomSerialized; import com.binance.dex.api.client.encoding.amino.WireType; +import com.binance.dex.api.client.encoding.serializer.EthAddressValueToStringSerializer; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; import com.google.protobuf.CodedInputStream; import com.google.protobuf.CodedOutputStream; import org.apache.commons.lang3.StringUtils; @@ -12,6 +14,7 @@ /** * @author Fitz.Lu **/ +@JsonSerialize(using = EthAddressValueToStringSerializer.class) public class EthAddressValue implements AminoCustomSerialized { private String address; diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryValidatorParams.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryValidatorParams.java index 6ec08ac..476c168 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryValidatorParams.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryValidatorParams.java @@ -1,9 +1,7 @@ package com.binance.dex.api.client.encoding.message.sidechain.query; import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; -import com.binance.dex.api.client.encoding.serializer.Bech32AddressValueToStringSerializer; import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.databind.annotation.JsonSerialize; /** * @author Fitz.Lu @@ -11,7 +9,6 @@ public class QueryValidatorParams extends BaseQueryParams { @JsonProperty(value = "ValidatorAddr") - @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) private Bech32AddressValue ValidatorAddress; public QueryValidatorParams() { diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/CreateSideChainValidatorMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/CreateSideChainValidatorMessage.java index 6fc20cb..4220eca 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/CreateSideChainValidatorMessage.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/CreateSideChainValidatorMessage.java @@ -6,11 +6,9 @@ import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; import com.binance.dex.api.client.encoding.message.common.CoinValueStr; import com.binance.dex.api.client.encoding.message.sidechain.value.*; -import com.binance.dex.api.client.encoding.serializer.Bech32AddressValueToStringSerializer; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.annotation.JsonPropertyOrder; -import com.fasterxml.jackson.databind.annotation.JsonSerialize; import org.apache.commons.lang3.StringUtils; import java.util.ArrayList; @@ -26,11 +24,9 @@ public class CreateSideChainValidatorMessage implements BinanceDexTransactionMes private CommissionMsgValue commission = new CommissionMsgValue(); @JsonProperty(value = "delegator_address") - @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) private Bech32AddressValue delegatorAddr; @JsonProperty(value = "validator_address") - @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) private Bech32AddressValue validatorOperatorAddr; @JsonProperty(value = "delegation") diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/EditSideChainValidatorMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/EditSideChainValidatorMessage.java index dbc5fac..b8d3374 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/EditSideChainValidatorMessage.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/EditSideChainValidatorMessage.java @@ -6,7 +6,6 @@ import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; import com.binance.dex.api.client.encoding.message.common.Dec; import com.binance.dex.api.client.encoding.message.sidechain.value.DescriptionValue; -import com.binance.dex.api.client.encoding.serializer.Bech32AddressValueToStringSerializer; import com.binance.dex.api.client.encoding.serializer.DecToStringSerializer; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; @@ -27,7 +26,6 @@ public class EditSideChainValidatorMessage implements BinanceDexTransactionMessa private DescriptionValue description; @JsonProperty(value = "address") - @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) private Bech32AddressValue validatorOperatorAddress; @JsonProperty(value = "commission_rate") diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainDelegateMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainDelegateMessage.java index b2c104b..7f2825c 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainDelegateMessage.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainDelegateMessage.java @@ -5,11 +5,9 @@ import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; import com.binance.dex.api.client.encoding.message.common.CoinValueStr; -import com.binance.dex.api.client.encoding.serializer.Bech32AddressValueToStringSerializer; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.annotation.JsonPropertyOrder; -import com.fasterxml.jackson.databind.annotation.JsonSerialize; import org.apache.commons.lang3.StringUtils; import java.util.ArrayList; @@ -22,11 +20,9 @@ public class SideChainDelegateMessage implements BinanceDexTransactionMessage, AminoSerializable { @JsonProperty(value = "delegator_addr") - @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) private Bech32AddressValue delegatorAddress; @JsonProperty(value = "validator_addr") - @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) private Bech32AddressValue validatorAddress; @JsonProperty(value = "delegation") diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainRedelegateMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainRedelegateMessage.java index b12022d..6705ed8 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainRedelegateMessage.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainRedelegateMessage.java @@ -5,11 +5,9 @@ import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; import com.binance.dex.api.client.encoding.message.common.CoinValueStr; -import com.binance.dex.api.client.encoding.serializer.Bech32AddressValueToStringSerializer; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.annotation.JsonPropertyOrder; -import com.fasterxml.jackson.databind.annotation.JsonSerialize; import org.apache.commons.lang3.StringUtils; import java.util.ArrayList; @@ -22,15 +20,12 @@ public class SideChainRedelegateMessage implements BinanceDexTransactionMessage, AminoSerializable { @JsonProperty(value = "delegator_addr") - @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) private Bech32AddressValue delegatorAddress; @JsonProperty(value = "validator_src_addr") - @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) private Bech32AddressValue srcValidatorAddress; @JsonProperty(value = "validator_dst_addr") - @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) private Bech32AddressValue dstValidatorAddress; @JsonProperty(value = "amount") diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainUndelegateMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainUndelegateMessage.java index 996ca39..f36823d 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainUndelegateMessage.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainUndelegateMessage.java @@ -5,11 +5,9 @@ import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; import com.binance.dex.api.client.encoding.message.common.CoinValueStr; -import com.binance.dex.api.client.encoding.serializer.Bech32AddressValueToStringSerializer; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.annotation.JsonPropertyOrder; -import com.fasterxml.jackson.databind.annotation.JsonSerialize; import org.apache.commons.lang3.StringUtils; import java.util.ArrayList; @@ -22,11 +20,9 @@ public class SideChainUndelegateMessage implements BinanceDexTransactionMessage, AminoSerializable { @JsonProperty(value = "delegator_addr") - @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) private Bech32AddressValue delegatorAddress; @JsonProperty(value = "validator_addr") - @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) private Bech32AddressValue validatorAddress; @JsonProperty(value = "amount") diff --git a/src/main/java/com/binance/dex/api/client/encoding/serializer/Bech32AddressValueToStringSerializer.java b/src/main/java/com/binance/dex/api/client/encoding/serializer/Bech32AddressValueToStringSerializer.java index a39981d..2f44607 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/serializer/Bech32AddressValueToStringSerializer.java +++ b/src/main/java/com/binance/dex/api/client/encoding/serializer/Bech32AddressValueToStringSerializer.java @@ -1,22 +1,37 @@ package com.binance.dex.api.client.encoding.serializer; import com.binance.dex.api.client.encoding.Crypto; +import com.binance.dex.api.client.encoding.EncodeUtils; import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.JsonSerializer; import com.fasterxml.jackson.databind.SerializerProvider; +import com.fasterxml.jackson.databind.ser.std.StdSerializer; +import org.apache.commons.lang3.StringUtils; import java.io.IOException; /** * @author Fitz.Lu **/ -public class Bech32AddressValueToStringSerializer extends JsonSerializer { +public class Bech32AddressValueToStringSerializer extends StdSerializer { + + protected Bech32AddressValueToStringSerializer(){ + this(null); + } + + protected Bech32AddressValueToStringSerializer(Class t) { + super(t); + } @Override public void serialize(Bech32AddressValue addressValue, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { - if (addressValue != null && addressValue.getHrp() != null && addressValue.getRaw() != null){ - jsonGenerator.writeString(Crypto.encodeAddress(addressValue.getHrp(), addressValue.getRaw())); + if (addressValue != null && addressValue.getRaw() != null) { + if (StringUtils.isNotBlank(addressValue.getHrp())){ + jsonGenerator.writeString(Crypto.encodeAddress(addressValue.getHrp(), addressValue.getRaw())); + } else { + jsonGenerator.writeString(EncodeUtils.bytesToHex(addressValue.getRaw())); + } } } } \ No newline at end of file diff --git a/src/main/java/com/binance/dex/api/client/encoding/serializer/EthAddressValueToStringSerializer.java b/src/main/java/com/binance/dex/api/client/encoding/serializer/EthAddressValueToStringSerializer.java index cda4cae..5268b6c 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/serializer/EthAddressValueToStringSerializer.java +++ b/src/main/java/com/binance/dex/api/client/encoding/serializer/EthAddressValueToStringSerializer.java @@ -4,13 +4,23 @@ import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.JsonSerializer; import com.fasterxml.jackson.databind.SerializerProvider; +import com.fasterxml.jackson.databind.ser.std.StdSerializer; import java.io.IOException; /** * @author Fitz.Lu **/ -public class EthAddressValueToStringSerializer extends JsonSerializer { +public class EthAddressValueToStringSerializer extends StdSerializer { + + protected EthAddressValueToStringSerializer(){ + this(null); + } + + protected EthAddressValueToStringSerializer(Class t) { + super(t); + } + @Override public void serialize(EthAddressValue ethAddressValue, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { if (ethAddressValue != null && ethAddressValue.getAddress() != null){ From 4d187fe08e4401b1df308f157880e74f610d8fb2 Mon Sep 17 00:00:00 2001 From: "fletcher.fan" Date: Tue, 7 Jul 2020 16:24:33 +0800 Subject: [PATCH 14/52] decoder for RLP --- pom.xml | 22 +++ .../dex/api/client/TransactionConverter.java | 10 +- .../client/crosschain/Bep2TokenSymbol.java | 23 +++ .../dex/api/client/crosschain/Content.java | 7 + .../api/client/crosschain/ContentEnum.java | 34 ++++ .../dex/api/client/crosschain/Package.java | 16 ++ .../dex/api/client/crosschain/Payload.java | 44 +++++ .../api/client/crosschain/UnsignedInt.java | 13 ++ .../api/client/crosschain/UnsignedLong.java | 13 ++ .../api/client/crosschain/UnsignedNumber.java | 34 ++++ .../api/client/crosschain/ValidatorSet.java | 30 ++++ .../crosschain/content/ApproveBindSyn.java | 22 +++ .../client/crosschain/content/BindSyn.java | 28 ++++ .../crosschain/content/CSCParamChange.java | 23 +++ .../client/crosschain/content/CommonAck.java | 18 +++ .../crosschain/content/IbcValidatorSet.java | 22 +++ .../crosschain/content/SideDowntimeSlash.java | 23 +++ .../crosschain/content/TransferInSyn.java | 31 ++++ .../crosschain/content/TransferOutRefund.java | 26 +++ .../crosschain/content/TransferOutSyn.java | 27 ++++ .../api/client/domain/oracle/ClaimMsg.java | 28 ++-- .../dex/api/client/encoding/ByteUtil.java | 19 +++ .../message/common/Bech32AddressValue.java | 8 +- .../message/common/EthAddressValue.java | 9 +- ...Bech32AddressValuesToStringSerializer.java | 29 ++++ .../serializer/Bep2TokenSymbolSerializer.java | 28 ++++ ...istBytesToPrefixedHexStringSerializer.java | 26 +++ .../serializer/UnsignedNumberSerializer.java | 25 +++ .../binance/dex/api/client/rlp/Decoder.java | 151 ++++++++++++++++++ .../dex/api/client/rlp/RlpDecodable.java | 7 + .../dex/api/client/encoding/rlp/RLPTest.java | 101 ++++++++++++ .../client/examples/BridgeNodeExample.java | 43 +++++ 32 files changed, 925 insertions(+), 15 deletions(-) create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/Bep2TokenSymbol.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/Content.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/ContentEnum.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/Package.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/Payload.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/UnsignedInt.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/UnsignedLong.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/UnsignedNumber.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/ValidatorSet.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/content/ApproveBindSyn.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/content/BindSyn.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/content/CSCParamChange.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/content/CommonAck.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/content/IbcValidatorSet.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/content/SideDowntimeSlash.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/content/TransferInSyn.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/content/TransferOutRefund.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/content/TransferOutSyn.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/serializer/Bech32AddressValuesToStringSerializer.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/serializer/Bep2TokenSymbolSerializer.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/serializer/ListBytesToPrefixedHexStringSerializer.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/serializer/UnsignedNumberSerializer.java create mode 100644 src/main/java/com/binance/dex/api/client/rlp/Decoder.java create mode 100644 src/main/java/com/binance/dex/api/client/rlp/RlpDecodable.java create mode 100644 src/test/java/com/binance/dex/api/client/encoding/rlp/RLPTest.java diff --git a/pom.xml b/pom.xml index 998cece..253e3e2 100644 --- a/pom.xml +++ b/pom.xml @@ -102,6 +102,28 @@ javax.annotation-api 1.3.2 + + + + org.ethereum + ethereumj-core + 1.12.0-RELEASE + + + org.ethereum + rocksdbjni + + + org.ethereum + solcJ-all + + + org.iq80.leveldb + leveldb + + + + diff --git a/src/main/java/com/binance/dex/api/client/TransactionConverter.java b/src/main/java/com/binance/dex/api/client/TransactionConverter.java index 2cab7ce..6bce540 100644 --- a/src/main/java/com/binance/dex/api/client/TransactionConverter.java +++ b/src/main/java/com/binance/dex/api/client/TransactionConverter.java @@ -1,5 +1,6 @@ package com.binance.dex.api.client; +import com.binance.dex.api.client.crosschain.Package; import com.binance.dex.api.client.domain.*; import com.binance.dex.api.client.domain.bridge.Bind; import com.binance.dex.api.client.domain.bridge.TransferOut; @@ -34,6 +35,7 @@ import com.binance.dex.api.client.domain.stake.sidechain.*; import com.binance.dex.api.client.encoding.ByteUtil; import com.binance.dex.api.client.encoding.Crypto; +import com.binance.dex.api.client.encoding.EncodeUtils; import com.binance.dex.api.client.encoding.amino.Amino; import com.binance.dex.api.client.encoding.message.InputOutput; import com.binance.dex.api.client.encoding.message.MessageType; @@ -43,6 +45,7 @@ import com.binance.dex.api.client.encoding.message.bridge.TransferOutMsgMessage; import com.binance.dex.api.client.encoding.message.bridge.UnbindMsgMessage; import com.binance.dex.api.client.encoding.message.sidechain.transaction.*; +import com.binance.dex.api.client.rlp.Decoder; import com.binance.dex.api.proto.*; import com.binance.dex.api.proto.TimeLock; import com.binance.dex.api.proto.TimeRelock; @@ -363,18 +366,19 @@ private Transaction convertTransferOutMsg(byte[] value) throws IOException { return transaction; } - private Transaction convertClaimMsg(byte[] value) throws IOException { + private Transaction convertClaimMsg(byte[] value) throws Exception { byte[] raw = ByteUtil.cut(value, 4); ClaimMsgMessage message = new ClaimMsgMessage(); amino.decodeBare(raw, message); ClaimMsg claimMsg = new ClaimMsg(); claimMsg.setChainId(message.getChainId()); claimMsg.setSequence(message.getSequence()); - claimMsg.setPayload(message.getPayload()); + List packages = Decoder.decodeList(message.getPayload(), Package.class); + packages.forEach(pack -> pack.setHrp(this.hrp)); + claimMsg.setPayload(packages); if (message.getValidatorAddress().getRaw() != null) { claimMsg.setValidatorAddress(Crypto.encodeAddress(valHrp, message.getValidatorAddress().getRaw())); } - Transaction transaction = new Transaction(); transaction.setTxType(TxType.CLAIM); transaction.setRealTx(claimMsg); diff --git a/src/main/java/com/binance/dex/api/client/crosschain/Bep2TokenSymbol.java b/src/main/java/com/binance/dex/api/client/crosschain/Bep2TokenSymbol.java new file mode 100644 index 0000000..16d1369 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/Bep2TokenSymbol.java @@ -0,0 +1,23 @@ +package com.binance.dex.api.client.crosschain; + +import com.binance.dex.api.client.encoding.ByteUtil; +import com.binance.dex.api.client.encoding.serializer.Bep2TokenSymbolSerializer; +import com.binance.dex.api.client.rlp.RlpDecodable; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +@JsonSerialize(using = Bep2TokenSymbolSerializer.class) +public class Bep2TokenSymbol implements RlpDecodable { + + private byte[] raw; + private String symbol; + + @Override + public void decode(byte[] raw, Object superInstance) { + this.setRaw(raw); + this.setSymbol(new String(ByteUtil.trim(raw,(byte)0))); + } +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/Content.java b/src/main/java/com/binance/dex/api/client/crosschain/Content.java new file mode 100644 index 0000000..ac62b29 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/Content.java @@ -0,0 +1,7 @@ +package com.binance.dex.api.client.crosschain; + +public abstract class Content { + + protected abstract void setHrp(String hrp); + +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/ContentEnum.java b/src/main/java/com/binance/dex/api/client/crosschain/ContentEnum.java new file mode 100644 index 0000000..9cb6ce0 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/ContentEnum.java @@ -0,0 +1,34 @@ +package com.binance.dex.api.client.crosschain; + +import com.binance.dex.api.client.crosschain.content.*; +import lombok.AllArgsConstructor; +import lombok.Getter; + +import java.util.Arrays; +import java.util.Optional; + +@Getter +@AllArgsConstructor +public enum ContentEnum { + ApproveBindSynPack(1, 0, ApproveBindSyn.class), + BindSynPack(1, 2, BindSyn.class), + TransferOutRefundPack(2, 1, TransferOutRefund.class), + TransferOutSynPack(2, 2, TransferOutSyn.class), + TransferInSynPack(3, 0, TransferInSyn.class), + StakingCommonAckPack(8, 1, CommonAck.class), + IbcValidatorSetPack(8, 2, IbcValidatorSet.class), + GovCommonAckPack(9, 1, CommonAck.class), + SideDowntimeSlashPack(11, 0, com.binance.dex.api.client.crosschain.content.SideDowntimeSlash.class), + ; + + private Integer channelId; + private Integer packType; + private Class clazz; + + public static Class getClass(Integer channelId, Integer packType) { + Optional optional = Arrays.stream(ContentEnum.values()) + .filter(contentEnum -> channelId.equals(contentEnum.channelId) && packType.equals(contentEnum.packType)) + .findAny(); + return optional.>map(ContentEnum::getClazz).orElse(null); + } +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/Package.java b/src/main/java/com/binance/dex/api/client/crosschain/Package.java new file mode 100644 index 0000000..9982146 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/Package.java @@ -0,0 +1,16 @@ +package com.binance.dex.api.client.crosschain; + +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +public class Package { + private UnsignedInt channelId; + private UnsignedLong sequence; + private Payload payload; + + public void setHrp(String hrp) { + payload.getContent().setHrp(hrp); + } +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/Payload.java b/src/main/java/com/binance/dex/api/client/crosschain/Payload.java new file mode 100644 index 0000000..97f026c --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/Payload.java @@ -0,0 +1,44 @@ +package com.binance.dex.api.client.crosschain; + +import com.binance.dex.api.client.encoding.ByteUtil; +import com.binance.dex.api.client.rlp.Decoder; +import com.binance.dex.api.client.rlp.RlpDecodable; +import lombok.Getter; +import lombok.Setter; + +import java.math.BigInteger; + +@Getter +@Setter +public class Payload implements RlpDecodable { + + private Integer packageType; + private BigInteger crossChainFee; + private Content content; + + public Payload(){} + + @Override + public void decode(byte[] raw, Object superInstance) throws Exception { + if (raw.length < 33) { + throw new RuntimeException("Failed to code: too less length for payload"); + } + this.setPackageType((int) ByteUtil.pick(raw, 0, 1)[0]); + this.setCrossChainFee(new BigInteger(ByteUtil.pick(raw, 1, 32))); + + Integer channelId; + if (superInstance instanceof Package) { + Package pack = (Package) superInstance; + channelId = pack.getChannelId().getValue(); + } else { + throw new RuntimeException("Failed to code: superInstance's class should be Package"); + } + + Class clazz = ContentEnum.getClass(channelId, this.getPackageType()); + if (clazz == null) { + throw new RuntimeException(String.format("unknown content of channel id = %s, package type = %s", channelId, this.getPackageType())); + } + Content instance = Decoder.decodeObject(ByteUtil.cut(raw, 33), clazz); + this.setContent(instance); + } +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/UnsignedInt.java b/src/main/java/com/binance/dex/api/client/crosschain/UnsignedInt.java new file mode 100644 index 0000000..3aec1e9 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/UnsignedInt.java @@ -0,0 +1,13 @@ +package com.binance.dex.api.client.crosschain; + +public class UnsignedInt extends UnsignedNumber { + + public UnsignedInt(){ + super(); + } + + public int getValue(){ + return super.getNumber().intValue(); + } + +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/UnsignedLong.java b/src/main/java/com/binance/dex/api/client/crosschain/UnsignedLong.java new file mode 100644 index 0000000..20906b9 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/UnsignedLong.java @@ -0,0 +1,13 @@ +package com.binance.dex.api.client.crosschain; + +public class UnsignedLong extends UnsignedNumber { + + public UnsignedLong(){ + super(); + } + + public long getValue(){ + return super.getNumber().longValue(); + } + +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/UnsignedNumber.java b/src/main/java/com/binance/dex/api/client/crosschain/UnsignedNumber.java new file mode 100644 index 0000000..43d16c6 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/UnsignedNumber.java @@ -0,0 +1,34 @@ +package com.binance.dex.api.client.crosschain; + +import com.binance.dex.api.client.encoding.serializer.UnsignedNumberSerializer; +import com.binance.dex.api.client.rlp.RlpDecodable; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; + +import java.math.BigInteger; + +@JsonSerialize(using = UnsignedNumberSerializer.class) +public class UnsignedNumber implements RlpDecodable { + + private BigInteger value; + + public UnsignedNumber() { + this.value = BigInteger.ZERO; + } + + public UnsignedNumber(BigInteger value) { + this.value = value; + } + + @Override + public void decode(byte[] raw, Object superInstance) { + this.value = new BigInteger(1, raw); + } + + public BigInteger getNumber() { + return value; + } + + public void setValue(BigInteger value) { + this.value = value; + } +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/ValidatorSet.java b/src/main/java/com/binance/dex/api/client/crosschain/ValidatorSet.java new file mode 100644 index 0000000..6964000 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/ValidatorSet.java @@ -0,0 +1,30 @@ +package com.binance.dex.api.client.crosschain; + +import com.binance.dex.api.client.encoding.serializer.BytesToPrefixedHexStringSerializer; +import com.binance.dex.api.client.rlp.Decoder; +import com.binance.dex.api.client.rlp.RlpDecodable; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +public class ValidatorSet implements RlpDecodable { + + @JsonSerialize(using = BytesToPrefixedHexStringSerializer.class) + private byte[] sideConsAddr; + @JsonSerialize(using = BytesToPrefixedHexStringSerializer.class) + private byte[] feeAddr; + @JsonSerialize(using = BytesToPrefixedHexStringSerializer.class) + private byte[] distAddr; + private Long power; + + @Override + public void decode(byte[] raw, Object superInstance) throws Exception { + ValidatorSet vs = Decoder.decodeObject(raw, ValidatorSet.class); + this.sideConsAddr = vs.sideConsAddr; + this.feeAddr = vs.feeAddr; + this.distAddr = vs.distAddr; + this.power = vs.power; + } +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/ApproveBindSyn.java b/src/main/java/com/binance/dex/api/client/crosschain/content/ApproveBindSyn.java new file mode 100644 index 0000000..1a6b974 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/ApproveBindSyn.java @@ -0,0 +1,22 @@ +package com.binance.dex.api.client.crosschain.content; + +import com.binance.dex.api.client.crosschain.Bep2TokenSymbol; +import com.binance.dex.api.client.crosschain.Content; +import com.binance.dex.api.client.crosschain.UnsignedInt; +import lombok.Getter; +import lombok.Setter; + + +@Getter +@Setter +public class ApproveBindSyn extends Content { + + private UnsignedInt status; + + private Bep2TokenSymbol symbol; + + @Override + protected void setHrp(String hrp) { + + } +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/BindSyn.java b/src/main/java/com/binance/dex/api/client/crosschain/content/BindSyn.java new file mode 100644 index 0000000..bb20cd9 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/BindSyn.java @@ -0,0 +1,28 @@ +package com.binance.dex.api.client.crosschain.content; + +import com.binance.dex.api.client.crosschain.*; +import com.binance.dex.api.client.encoding.message.common.EthAddressValue; +import com.binance.dex.api.client.encoding.serializer.Bep2TokenSymbolSerializer; +import com.binance.dex.api.client.encoding.serializer.BytesToPrefixedHexStringSerializer; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import lombok.Getter; +import lombok.Setter; + +import java.math.BigInteger; + +@Getter +@Setter +public class BindSyn extends Content { + + private UnsignedInt packageType; + private Bep2TokenSymbol symbol; + private EthAddressValue contractAddr; + private UnsignedNumber totalSupply; + private UnsignedNumber peggyAmount; + private UnsignedInt decimals; + private UnsignedLong expireTime; + + @Override + protected void setHrp(String hrp) { + } +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/CSCParamChange.java b/src/main/java/com/binance/dex/api/client/crosschain/content/CSCParamChange.java new file mode 100644 index 0000000..f95cf1a --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/CSCParamChange.java @@ -0,0 +1,23 @@ +package com.binance.dex.api.client.crosschain.content; + +import com.binance.dex.api.client.crosschain.Content; +import com.binance.dex.api.client.encoding.serializer.BytesToPrefixedHexStringSerializer; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +public class CSCParamChange extends Content { + + private String key; + @JsonSerialize(using = BytesToPrefixedHexStringSerializer.class) + private byte[] value; + @JsonSerialize(using = BytesToPrefixedHexStringSerializer.class) + private byte[] target; + + @Override + protected void setHrp(String hrp) { + + } +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/CommonAck.java b/src/main/java/com/binance/dex/api/client/crosschain/content/CommonAck.java new file mode 100644 index 0000000..584a77a --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/CommonAck.java @@ -0,0 +1,18 @@ +package com.binance.dex.api.client.crosschain.content; + +import com.binance.dex.api.client.crosschain.Content; +import com.binance.dex.api.client.crosschain.UnsignedInt; +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +public class CommonAck extends Content { + + private UnsignedInt code; + + @Override + protected void setHrp(String hrp) { + + } +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/IbcValidatorSet.java b/src/main/java/com/binance/dex/api/client/crosschain/content/IbcValidatorSet.java new file mode 100644 index 0000000..e680430 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/IbcValidatorSet.java @@ -0,0 +1,22 @@ +package com.binance.dex.api.client.crosschain.content; + +import com.binance.dex.api.client.crosschain.Content; +import com.binance.dex.api.client.crosschain.UnsignedInt; +import com.binance.dex.api.client.crosschain.ValidatorSet; +import lombok.Getter; +import lombok.Setter; + +import java.util.List; + +@Getter +@Setter +public class IbcValidatorSet extends Content { + + private UnsignedInt type; + private List ibcValidator; + + @Override + protected void setHrp(String hrp) { + + } +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/SideDowntimeSlash.java b/src/main/java/com/binance/dex/api/client/crosschain/content/SideDowntimeSlash.java new file mode 100644 index 0000000..5bee5a3 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/SideDowntimeSlash.java @@ -0,0 +1,23 @@ +package com.binance.dex.api.client.crosschain.content; + +import com.binance.dex.api.client.crosschain.Content; +import com.binance.dex.api.client.crosschain.UnsignedInt; +import com.binance.dex.api.client.crosschain.UnsignedLong; +import com.binance.dex.api.client.encoding.serializer.BytesToPrefixedHexStringSerializer; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +public class SideDowntimeSlash extends Content { + + @JsonSerialize(using = BytesToPrefixedHexStringSerializer.class) + private byte[] sideConsAddr; + private UnsignedLong sideHeight; + private UnsignedInt sideChainId; + private UnsignedLong sideTimestamp; + + @Override + protected void setHrp(String hrp) {} +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/TransferInSyn.java b/src/main/java/com/binance/dex/api/client/crosschain/content/TransferInSyn.java new file mode 100644 index 0000000..39ab1e5 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/TransferInSyn.java @@ -0,0 +1,31 @@ +package com.binance.dex.api.client.crosschain.content; + +import com.binance.dex.api.client.crosschain.Bep2TokenSymbol; +import com.binance.dex.api.client.crosschain.Content; +import com.binance.dex.api.client.crosschain.UnsignedLong; +import com.binance.dex.api.client.crosschain.UnsignedNumber; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.encoding.message.common.EthAddressValue; +import lombok.Getter; +import lombok.Setter; + +import java.util.List; + +@Getter +@Setter +public class TransferInSyn extends Content { + + private Bep2TokenSymbol symbol; + private EthAddressValue contractAddress; + private List amounts; + private List receiverAddresses; + private List refundAddresses; + private UnsignedLong expireTime; + + @Override + protected void setHrp(String hrp) { + if (receiverAddresses != null) { + receiverAddresses.forEach(addr -> addr.setHrp(hrp)); + } + } +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/TransferOutRefund.java b/src/main/java/com/binance/dex/api/client/crosschain/content/TransferOutRefund.java new file mode 100644 index 0000000..75ad96f --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/TransferOutRefund.java @@ -0,0 +1,26 @@ +package com.binance.dex.api.client.crosschain.content; + +import com.binance.dex.api.client.crosschain.Bep2TokenSymbol; +import com.binance.dex.api.client.crosschain.Content; +import com.binance.dex.api.client.crosschain.UnsignedInt; +import com.binance.dex.api.client.crosschain.UnsignedNumber; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import lombok.Getter; +import lombok.Setter; + + +@Getter +@Setter +public class TransferOutRefund extends Content { + + private Bep2TokenSymbol symbol; + private UnsignedNumber refundAmount; + private Bech32AddressValue refundAddr; + private UnsignedInt refundReason; + + + @Override + protected void setHrp(String hrp) { + this.refundAddr.setHrp(hrp); + } +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/TransferOutSyn.java b/src/main/java/com/binance/dex/api/client/crosschain/content/TransferOutSyn.java new file mode 100644 index 0000000..4ad1942 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/TransferOutSyn.java @@ -0,0 +1,27 @@ +package com.binance.dex.api.client.crosschain.content; + +import com.binance.dex.api.client.crosschain.Bep2TokenSymbol; +import com.binance.dex.api.client.crosschain.Content; +import com.binance.dex.api.client.crosschain.UnsignedLong; +import com.binance.dex.api.client.crosschain.UnsignedNumber; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import lombok.Getter; +import lombok.Setter; + + +@Getter +@Setter +public class TransferOutSyn extends Content { + + private Bep2TokenSymbol symbol; + private Bech32AddressValue contractAddress; + private UnsignedNumber amount; + private Bech32AddressValue recipient; + private Bech32AddressValue refundAddress; + private UnsignedLong expireTime; + + @Override + protected void setHrp(String hrp) { + this.refundAddress.setHrp(hrp); + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/oracle/ClaimMsg.java b/src/main/java/com/binance/dex/api/client/domain/oracle/ClaimMsg.java index 81543c5..c7bcbf8 100644 --- a/src/main/java/com/binance/dex/api/client/domain/oracle/ClaimMsg.java +++ b/src/main/java/com/binance/dex/api/client/domain/oracle/ClaimMsg.java @@ -1,6 +1,10 @@ package com.binance.dex.api.client.domain.oracle; -import org.apache.commons.codec.binary.Hex; +import com.binance.dex.api.client.crosschain.Package; +import com.binance.dex.api.client.encoding.EncodeUtils; +import com.fasterxml.jackson.core.JsonProcessingException; + +import java.util.List; /** * @author Fitz.Lu @@ -11,7 +15,7 @@ public class ClaimMsg { private long sequence; - private byte[] payload; + private List payload; private String validatorAddress; @@ -31,11 +35,11 @@ public void setSequence(long sequence) { this.sequence = sequence; } - public byte[] getPayload() { + public List getPayload() { return payload; } - public void setPayload(byte[] payload) { + public void setPayload(List payload) { this.payload = payload; } @@ -49,11 +53,15 @@ public void setValidatorAddress(String validatorAddress) { @Override public String toString() { - return "ClaimMsg{" + - "chainId=" + chainId + - ", sequence=" + sequence + - ", payload='" + Hex.encodeHexString(payload) + '\'' + - ", validatorAddress='" + validatorAddress + '\'' + - '}'; + try { + return "ClaimMsg{" + + "chainId=" + chainId + + ", sequence=" + sequence + + ", payload='" + EncodeUtils.toJsonStringSortKeys(payload) + '\'' + + ", validatorAddress='" + validatorAddress + '\'' + + '}'; + } catch (JsonProcessingException e) { + throw new RuntimeException("failed to encode payload", e); + } } } diff --git a/src/main/java/com/binance/dex/api/client/encoding/ByteUtil.java b/src/main/java/com/binance/dex/api/client/encoding/ByteUtil.java index 005dfc7..a12c44e 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/ByteUtil.java +++ b/src/main/java/com/binance/dex/api/client/encoding/ByteUtil.java @@ -1,5 +1,7 @@ package com.binance.dex.api.client.encoding; +import java.util.Arrays; + /** * @author Fitz.Lu **/ @@ -35,6 +37,23 @@ public static byte[] pick(byte[] bytes, int start, int length){ return newBytes; } + public static byte[] trim(byte[] bytes, byte b){ + requireByteArrayNotEmpty(bytes); + byte[] newBytes = new byte[0]; + for(byte bb : bytes){ + if (bb != b){ + newBytes = appendByte(newBytes,bb); + } + } + return newBytes; + } + + public static byte[] appendByte(byte[] bytes, byte b) { + byte[] result = Arrays.copyOf(bytes, bytes.length + 1); + result[result.length - 1] = b; + return result; + } + public static byte[] appendBytesArray(byte[] first, byte[] second){ if (first == null){ throw new NullPointerException("first byte array is null"); diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/common/Bech32AddressValue.java b/src/main/java/com/binance/dex/api/client/encoding/message/common/Bech32AddressValue.java index e185e68..fafb951 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/common/Bech32AddressValue.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/common/Bech32AddressValue.java @@ -6,6 +6,7 @@ import com.binance.dex.api.client.encoding.amino.AminoCustomSerialized; import com.binance.dex.api.client.encoding.amino.WireType; import com.binance.dex.api.client.encoding.serializer.Bech32AddressValueToStringSerializer; +import com.binance.dex.api.client.rlp.RlpDecodable; import com.fasterxml.jackson.databind.annotation.JsonSerialize; import com.google.protobuf.CodedInputStream; import com.google.protobuf.CodedOutputStream; @@ -16,7 +17,7 @@ * @author Fitz.Lu **/ @JsonSerialize(using = Bech32AddressValueToStringSerializer.class) -public class Bech32AddressValue implements AminoCustomSerialized { +public class Bech32AddressValue implements AminoCustomSerialized, RlpDecodable { private String hrp; @@ -93,4 +94,9 @@ public int getSerializedSize() { return CodedOutputStream.computeByteArraySizeNoTag(raw); } } + + @Override + public void decode(byte[] raw, Object superInstance) { + this.raw = raw; + } } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/common/EthAddressValue.java b/src/main/java/com/binance/dex/api/client/encoding/message/common/EthAddressValue.java index c580e74..bb9506e 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/common/EthAddressValue.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/common/EthAddressValue.java @@ -3,6 +3,7 @@ import com.binance.dex.api.client.encoding.amino.AminoCustomSerialized; import com.binance.dex.api.client.encoding.amino.WireType; import com.binance.dex.api.client.encoding.serializer.EthAddressValueToStringSerializer; +import com.binance.dex.api.client.rlp.RlpDecodable; import com.fasterxml.jackson.databind.annotation.JsonSerialize; import com.google.protobuf.CodedInputStream; import com.google.protobuf.CodedOutputStream; @@ -15,7 +16,7 @@ * @author Fitz.Lu **/ @JsonSerialize(using = EthAddressValueToStringSerializer.class) -public class EthAddressValue implements AminoCustomSerialized { +public class EthAddressValue implements AminoCustomSerialized, RlpDecodable { private String address; @@ -81,4 +82,10 @@ private byte[] getValueBytes(){ } return Hex.decode(addr); } + + @Override + public void decode(byte[] raw, Object superInstance) { + address = Hex.toHexString(raw); + address = "0x" + address; + } } diff --git a/src/main/java/com/binance/dex/api/client/encoding/serializer/Bech32AddressValuesToStringSerializer.java b/src/main/java/com/binance/dex/api/client/encoding/serializer/Bech32AddressValuesToStringSerializer.java new file mode 100644 index 0000000..5276dc2 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/serializer/Bech32AddressValuesToStringSerializer.java @@ -0,0 +1,29 @@ +package com.binance.dex.api.client.encoding.serializer; + +import com.binance.dex.api.client.encoding.Crypto; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.databind.JsonSerializer; +import com.fasterxml.jackson.databind.SerializerProvider; +import org.apache.commons.lang3.StringUtils; + +import java.io.IOException; +import java.util.List; +import java.util.stream.Collectors; + +public class Bech32AddressValuesToStringSerializer extends JsonSerializer> { + + @Override + public void serialize(List bech32AddressValues, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { + if (bech32AddressValues != null) { + List msg = bech32AddressValues.stream().map(value -> { + if (value.getRaw() != null && StringUtils.isNotBlank(value.getHrp())) { + return Crypto.encodeAddress(value.getHrp(), value.getRaw()); + } else { + throw new RuntimeException("raw and hrp must not be empty"); + } + }).collect(Collectors.toList()); + jsonGenerator.writeObject(msg); + } + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/serializer/Bep2TokenSymbolSerializer.java b/src/main/java/com/binance/dex/api/client/encoding/serializer/Bep2TokenSymbolSerializer.java new file mode 100644 index 0000000..250da29 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/serializer/Bep2TokenSymbolSerializer.java @@ -0,0 +1,28 @@ +package com.binance.dex.api.client.encoding.serializer; + +import com.binance.dex.api.client.crosschain.Bep2TokenSymbol; +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.databind.JsonSerializer; +import com.fasterxml.jackson.databind.SerializerProvider; +import com.fasterxml.jackson.databind.ser.std.StdSerializer; +import org.apache.commons.lang3.StringUtils; + +import java.io.IOException; + +public class Bep2TokenSymbolSerializer extends StdSerializer { + + protected Bep2TokenSymbolSerializer(){ + this(null); + } + + protected Bep2TokenSymbolSerializer(Class t) { + super(t); + } + + @Override + public void serialize(Bep2TokenSymbol bep2TokenSymbol, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { + if (bep2TokenSymbol != null && StringUtils.isNotBlank(bep2TokenSymbol.getSymbol())){ + jsonGenerator.writeString(bep2TokenSymbol.getSymbol()); + } + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/serializer/ListBytesToPrefixedHexStringSerializer.java b/src/main/java/com/binance/dex/api/client/encoding/serializer/ListBytesToPrefixedHexStringSerializer.java new file mode 100644 index 0000000..0e18394 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/serializer/ListBytesToPrefixedHexStringSerializer.java @@ -0,0 +1,26 @@ +package com.binance.dex.api.client.encoding.serializer; + +import com.binance.dex.api.client.encoding.EncodeUtils; +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.databind.JsonSerializer; +import com.fasterxml.jackson.databind.SerializerProvider; + +import java.io.IOException; +import java.util.List; +import java.util.stream.Collectors; + +public class ListBytesToPrefixedHexStringSerializer extends JsonSerializer> { + + @Override + public void serialize(List bytesList, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { + if (bytesList != null){ + List list = bytesList.stream().map(item -> { + if (item != null) { + return EncodeUtils.bytesToPrefixHex(item); + } + return ""; + }).collect(Collectors.toList()); + jsonGenerator.writeObject(list); + } + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/serializer/UnsignedNumberSerializer.java b/src/main/java/com/binance/dex/api/client/encoding/serializer/UnsignedNumberSerializer.java new file mode 100644 index 0000000..66dfe04 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/serializer/UnsignedNumberSerializer.java @@ -0,0 +1,25 @@ +package com.binance.dex.api.client.encoding.serializer; + +import com.binance.dex.api.client.crosschain.UnsignedNumber; +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.databind.SerializerProvider; +import com.fasterxml.jackson.databind.ser.std.StdSerializer; + +import java.io.IOException; + +public class UnsignedNumberSerializer extends StdSerializer { + + protected UnsignedNumberSerializer() { + this(null); + } + + + protected UnsignedNumberSerializer(Class t) { + super(t); + } + + @Override + public void serialize(UnsignedNumber unsignedNumber, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { + jsonGenerator.writeNumber(unsignedNumber.getNumber()); + } +} diff --git a/src/main/java/com/binance/dex/api/client/rlp/Decoder.java b/src/main/java/com/binance/dex/api/client/rlp/Decoder.java new file mode 100644 index 0000000..21d2c35 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/rlp/Decoder.java @@ -0,0 +1,151 @@ +package com.binance.dex.api.client.rlp; + +import com.binance.dex.api.client.crosschain.UnsignedNumber; +import com.binance.dex.api.client.encoding.EncodeUtils; +import org.ethereum.util.DecodeResult; +import org.ethereum.util.RLP; + +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.lang.reflect.ParameterizedType; +import java.lang.reflect.Type; +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.List; + +public class Decoder extends RLP { + + public static List decodeList(byte[] raw, Class clazz) throws Exception { + DecodeResult decodeResult = decode(raw, 0); + if (!(decodeResult.getDecoded() instanceof Object[])) { + throw new RuntimeException("not a list"); + } + Object[] objects = (Object[]) decodeResult.getDecoded(); + return decodeList(objects, clazz); + } + + private static List decodeList(Object[] objects, Class clazz) throws Exception { + List list = new ArrayList<>(); + for (Object ob : objects) { + if (ob instanceof byte[]) { + list.add((T) decodeBytes((byte[]) ob, clazz, null)); + } else if (ob instanceof Object[]) { + Object[] fieldValues = (Object[]) ob; + list.add(decodeObject(fieldValues, clazz)); + } + } + return list; + } + + public static T decodeObject(byte[] raw, Class clazz) throws Exception { + DecodeResult decodeResult = decode(raw, 0); + return decodeObject((Object[]) decodeResult.getDecoded(), clazz); + } + + + private static Object decodeBytes(byte[] value, Class type, Object superInstance) throws Exception { + if (type == Integer.class) { + + return decodeInt(value, 0); + + } else if (type == Long.class) { + + return decodeLong(value, 0); + + } else if (type == BigInteger.class) { + + return decodeBigInteger(value, 0); + + } else if (type == String.class) { + + return new String(value); + + } else if (type == byte[].class) { + + return value; + + } else if (isImplement(type, RlpDecodable.class)) { + + Method method = type.getMethod("decode", byte[].class, Object.class); + Object instance = type.newInstance(); + method.invoke(instance, value, superInstance); + return instance; + + } else { + throw new RuntimeException(String.format("unsupported type: %s ", type.getCanonicalName())); + } + } + + private static T decodeObject(Object[] fieldValues, Class clazz) throws Exception { + Field[] fields = clazz.getDeclaredFields(); + T instance = clazz.newInstance(); + if (fieldValues.length != fields.length) { + throw new RuntimeException("failed to decode, inconsistent fields numbers"); + } + for (int i = 0; i < fieldValues.length; i++) { + Object fieldValue = fieldValues[i]; + Field field = fields[i]; + + field.setAccessible(true); + if (fieldValue.equals("")) { + Class fieldType = field.getType(); + if (fieldType == Integer.class) { + field.set(instance, 0); + } else if (fieldType == Long.class) { + field.set(instance, 0L); + } else if (fieldType == UnsignedNumber.class || fieldType.getSuperclass() == UnsignedNumber.class){ + field.set(instance, fieldType.newInstance()); + } else { + throw new RuntimeException(String.format("Failed to decode %s, its type should be Integer or Long or UnsignedNumber", field.getName())); + } + } else if (fieldValue instanceof byte[]) { + Class fieldType = field.getType(); + field.set(instance, decodeBytes((byte[]) fieldValue, fieldType, instance)); + } else if (fieldValue instanceof Object[]) { + + Class fieldType = field.getType(); + if (fieldType == List.class) { + Type genericType = field.getGenericType(); + if (!(genericType instanceof ParameterizedType)) { + throw new RuntimeException(String.format("Failed to decode %s, can not decode List without generic type", field.getName())); + } + ParameterizedType pt = (ParameterizedType) genericType; + Class genericClazz = (Class) pt.getActualTypeArguments()[0]; + field.set(instance, decodeList((Object[]) fieldValue, genericClazz)); + } else { + throw new RuntimeException(String.format("Failed to decode %s, only List is supported as an array type", field.getName())); + } + } else { + throw new RuntimeException("ERROR: unrecognised type for RLP encoded bytes"); + } + } + + return instance; + } + + private static boolean isImplement(Class clazz, Class interfaceClass) { + for (Class item : clazz.getInterfaces()) { + if (item == interfaceClass) { + return true; + } + } + for (Class item : clazz.getSuperclass().getInterfaces()) { + if (item == interfaceClass) { + return true; + } + } + return false; + } + + + public static void main(String[] args) throws Exception { + byte[] bz = encodeInt(-100); + System.out.printf("result: %s\n", EncodeUtils.bytesToHex(bz)); + + byte[] bz1 = EncodeUtils.hexStringToByteArray("100000"); + + int r = decodeInt(bz1, 0); + System.out.println(r); + } + +} diff --git a/src/main/java/com/binance/dex/api/client/rlp/RlpDecodable.java b/src/main/java/com/binance/dex/api/client/rlp/RlpDecodable.java new file mode 100644 index 0000000..dbca877 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/rlp/RlpDecodable.java @@ -0,0 +1,7 @@ +package com.binance.dex.api.client.rlp; + +public interface RlpDecodable { + + void decode(byte[] raw, Object superInstance) throws Exception; + +} diff --git a/src/test/java/com/binance/dex/api/client/encoding/rlp/RLPTest.java b/src/test/java/com/binance/dex/api/client/encoding/rlp/RLPTest.java new file mode 100644 index 0000000..d787e11 --- /dev/null +++ b/src/test/java/com/binance/dex/api/client/encoding/rlp/RLPTest.java @@ -0,0 +1,101 @@ +package com.binance.dex.api.client.encoding.rlp; + + +import com.binance.dex.api.client.crosschain.Package; +import com.binance.dex.api.client.crosschain.Payload; +import com.binance.dex.api.client.crosschain.content.ApproveBindSyn; +import com.binance.dex.api.client.crosschain.content.SideDowntimeSlash; +import com.binance.dex.api.client.crosschain.content.TransferInSyn; +import com.binance.dex.api.client.crosschain.content.TransferOutRefund; +import com.binance.dex.api.client.encoding.Crypto; +import com.binance.dex.api.client.encoding.EncodeUtils; +import com.binance.dex.api.client.rlp.Decoder; +import org.bouncycastle.util.encoders.Hex; +import org.junit.Assert; +import org.junit.Test; + + +import java.math.BigInteger; +import java.util.List; + +public class RLPTest { + + @Test + public void testApproveBindSynDecode() throws Exception { + byte[] raw = Hex.decode("f84af8480110b8440000000000000000000000000000000000000000000000000000000000000f4240e280a04142432d44453700000000000000000000000000000000000000000000000000"); + List result = Decoder.decodeList(raw, Package.class); + Assert.assertEquals(1, result.size()); + Assert.assertEquals(1, result.get(0).getChannelId().getValue()); + Assert.assertEquals(16, result.get(0).getSequence().getNumber().longValue()); + Payload payload = result.get(0).getPayload(); + Assert.assertEquals(0, (int) payload.getPackageType()); + Assert.assertEquals(new BigInteger("1000000"), payload.getCrossChainFee()); + Assert.assertTrue(payload.getContent() instanceof ApproveBindSyn); + ApproveBindSyn approveBindSyn = (ApproveBindSyn) payload.getContent(); + Assert.assertEquals(0, approveBindSyn.getStatus().getValue()); + Assert.assertEquals("ABC-DE7", approveBindSyn.getSymbol().getSymbol()); + } + + @Test + public void testTransferOutRefundDecode() throws Exception { + byte[] raw = Hex.decode("f865f8630280b85f010000000000000000000000000000000000000000000000000000000000000000f83ca0424e4200000000000000000000000000000000000000000000000000000000008401312d009425016278faceb917ed90ec5d940352965ac096ad01"); + List result = Decoder.decodeList(raw, Package.class); + result.forEach(pack -> pack.setHrp("tbnb")); + Assert.assertEquals(1, result.size()); + Assert.assertEquals(2, result.get(0).getChannelId().getValue()); + Assert.assertEquals(0, result.get(0).getSequence().getNumber().longValue()); + Payload payload = result.get(0).getPayload(); + Assert.assertEquals(1, (int) payload.getPackageType()); + Assert.assertEquals(new BigInteger("0"), payload.getCrossChainFee()); + Assert.assertTrue(payload.getContent() instanceof TransferOutRefund); + TransferOutRefund transferOutRefund = (TransferOutRefund) payload.getContent(); + Assert.assertEquals("BNB", transferOutRefund.getSymbol().getSymbol()); + Assert.assertEquals(20000000L, transferOutRefund.getRefundAmount().getNumber().longValue()); + Assert.assertEquals("tbnb1y5qky786e6u30mvsa3wegq6jjedvp94dfeyvkw", Crypto.encodeAddress("tbnb", transferOutRefund.getRefundAddr().getRaw())); + Assert.assertEquals(1, transferOutRefund.getRefundReason().getValue()); + } + + @Test + public void testTransferInSyncDecode() throws Exception { + byte[] raw = Hex.decode("f8c7f8c5038306985ab8be0000000000000000000000000000000000000000000000000000000000001e8480f89ba0424e420000000000000000000000000000000000000000000000000000000000940000000000000000000000000000000000000000c9831e84808401312d00ea9425016278faceb917ed90ec5d940352965ac096ad943ece21ac0d97a24d004a6778babda59bbb167deaea9456ec2590d32b63a04f0a8613a85ab829dfc0ef259456ec2590d32b63a04f0a8613a85ab829dfc0ef25845f0415ea"); + List result = Decoder.decodeList(raw, Package.class); + result.forEach(pack -> pack.setHrp("tbnb")); + Assert.assertEquals(1, result.size()); + Assert.assertEquals(3, result.get(0).getChannelId().getValue()); + Assert.assertEquals(432218, result.get(0).getSequence().getNumber().longValue()); + Payload payload = result.get(0).getPayload(); + Assert.assertEquals(0, (int) payload.getPackageType()); + Assert.assertEquals(new BigInteger("2000000"), payload.getCrossChainFee()); + Assert.assertTrue(payload.getContent() instanceof TransferInSyn); + TransferInSyn transferInSyn = (TransferInSyn) payload.getContent(); + Assert.assertEquals("BNB", transferInSyn.getSymbol().getSymbol()); + Assert.assertEquals("0x0000000000000000000000000000000000000000", transferInSyn.getContractAddress().getAddress()); + Assert.assertEquals(2000000, transferInSyn.getAmounts().get(0).getNumber().longValue()); + Assert.assertEquals(20000000, transferInSyn.getAmounts().get(1).getNumber().longValue()); + Assert.assertEquals("tbnb1y5qky786e6u30mvsa3wegq6jjedvp94dfeyvkw", Crypto.encodeAddress("tbnb", transferInSyn.getReceiverAddresses().get(0).getRaw())); + Assert.assertEquals("tbnb18m8zrtqdj73y6qz2vaut40d9nwa3vl02vmyvez", Crypto.encodeAddress("tbnb", transferInSyn.getReceiverAddresses().get(1).getRaw())); + Assert.assertEquals("0x56ec2590d32b63a04f0a8613a85ab829dfc0ef25", transferInSyn.getRefundAddresses().get(0).getAddress()); + Assert.assertEquals("0x56ec2590d32b63a04f0a8613a85ab829dfc0ef25", transferInSyn.getRefundAddresses().get(1).getAddress()); + Assert.assertEquals(1594103274L, transferInSyn.getExpireTime().getValue()); + } + + @Test + public void testSlashDowntimeDecode() throws Exception { + byte[] raw = Hex.decode("f847f8450b80b841000000000000000000000000000000000000000000000000000000000000000000df940dd11a413972d8b1e1367c4b9196f75348424e708301c23c60845f02fca7"); + List result = Decoder.decodeList(raw, Package.class); + result.forEach(pack -> pack.setHrp("tbnb")); + Assert.assertEquals(1, result.size()); + Assert.assertEquals(11, result.get(0).getChannelId().getValue()); + Assert.assertEquals(0, result.get(0).getSequence().getNumber().longValue()); + Payload payload = result.get(0).getPayload(); + Assert.assertEquals(0, (int) payload.getPackageType()); + Assert.assertEquals(new BigInteger("0"), payload.getCrossChainFee()); + Assert.assertTrue(payload.getContent() instanceof SideDowntimeSlash); + SideDowntimeSlash sideDowntimeSlash = (SideDowntimeSlash) payload.getContent(); + Assert.assertEquals("0x0dd11a413972d8b1e1367c4b9196f75348424e70", EncodeUtils.bytesToPrefixHex(sideDowntimeSlash.getSideConsAddr())); + Assert.assertEquals(115260, sideDowntimeSlash.getSideHeight().getValue()); + Assert.assertEquals(96, sideDowntimeSlash.getSideChainId().getValue()); + Assert.assertEquals(1594031271, sideDowntimeSlash.getSideTimestamp().getValue()); + } + +} diff --git a/src/test/java/com/binance/dex/api/client/examples/BridgeNodeExample.java b/src/test/java/com/binance/dex/api/client/examples/BridgeNodeExample.java index 9ee72c0..7731936 100644 --- a/src/test/java/com/binance/dex/api/client/examples/BridgeNodeExample.java +++ b/src/test/java/com/binance/dex/api/client/examples/BridgeNodeExample.java @@ -4,15 +4,21 @@ import com.binance.dex.api.client.BinanceDexApiNodeClient; import com.binance.dex.api.client.BinanceDexEnvironment; import com.binance.dex.api.client.Wallet; +import com.binance.dex.api.client.crosschain.Package; import com.binance.dex.api.client.domain.TransactionMetadata; import com.binance.dex.api.client.domain.bridge.TransferIn; +import com.binance.dex.api.client.domain.broadcast.Transaction; import com.binance.dex.api.client.domain.broadcast.TransactionOption; +import com.binance.dex.api.client.domain.oracle.ClaimMsg; import com.binance.dex.api.client.domain.oracle.Prophecy; import com.binance.dex.api.client.encoding.EncodeUtils; import com.binance.dex.api.client.encoding.message.Token; import com.binance.dex.api.client.encoding.message.bridge.BindStatus; +import com.binance.dex.api.client.encoding.message.bridge.ClaimMsgMessage; import com.binance.dex.api.client.encoding.message.bridge.ClaimTypes; import com.binance.dex.api.client.encoding.message.bridge.RefundReason; +import com.fasterxml.jackson.core.JsonProcessingException; +import org.apache.commons.codec.binary.Hex; import org.junit.Assert; import org.junit.Before; import org.junit.Test; @@ -38,6 +44,43 @@ public void setup() throws IOException { wallet = Wallet.createWalletFromMnemonicCode(Arrays.asList(mnemonic.split(" ")), BinanceDexEnvironment.TEST_NET); } + @Test + public void t() throws JsonProcessingException { + System.out.println(); + Transaction transaction = nodeClient.getTransaction("0757F090A88F99436A6E1B138EA5ED1A5F2A8CC46BF03912F663119A5924DF62"); + ClaimMsg msg = (ClaimMsg)transaction.getRealTx(); + List packages = msg.getPayload(); + System.out.println(EncodeUtils.toJsonStringSortKeys(packages)); + + System.out.println(); + + transaction = nodeClient.getTransaction("59619D76EAB7B5D3FCE17589B6735869A49B77B5A059168731EA31ACE5A3119D"); + msg = (ClaimMsg)transaction.getRealTx(); + packages = msg.getPayload(); + System.out.println(EncodeUtils.toJsonStringSortKeys(packages)); + + System.out.println(); + + transaction = nodeClient.getTransaction("35568AB9D81409A54B38C11924C8B3BB374B8A57A4FF2070EF71BB393E94EE02"); + msg = (ClaimMsg)transaction.getRealTx(); + packages = msg.getPayload(); + System.out.println(EncodeUtils.toJsonStringSortKeys(packages)); + + System.out.println(); + + transaction = nodeClient.getTransaction("29FE859C0B40F73996346FBD9261B4F8B28C8381F13F3D3DCAE87ED3C6EE0A72"); + msg = (ClaimMsg)transaction.getRealTx(); + packages = msg.getPayload(); + System.out.println(EncodeUtils.toJsonStringSortKeys(packages)); + + System.out.println(); + + transaction = nodeClient.getTransaction("362BA6ACD9A831AC30D1C83AAD02F954C38940DCB91610DA4EA43CF7DCEAE0EA"); + msg = (ClaimMsg)transaction.getRealTx(); + packages = msg.getPayload(); + System.out.println(EncodeUtils.toJsonStringSortKeys(packages)); + } + @Test public void transferIn() throws IOException, NoSuchAlgorithmException { TransferIn transferIn = new TransferIn(); From b7f87bcb2dd97308a2cddef38dc088fd8c06f12a Mon Sep 17 00:00:00 2001 From: "fletcher.fan" Date: Thu, 9 Jul 2020 10:07:20 +0800 Subject: [PATCH 15/52] rename bep2tokensymbol to tokensymbol --- ...{Bep2TokenSymbol.java => TokenSymbol.java} | 6 ++-- .../crosschain/content/ApproveBindSyn.java | 4 +-- .../client/crosschain/content/BindSyn.java | 7 +---- .../crosschain/content/TransferInSyn.java | 4 +-- .../crosschain/content/TransferOutRefund.java | 4 +-- .../crosschain/content/TransferOutSyn.java | 4 +-- .../serializer/Bep2TokenSymbolSerializer.java | 28 ------------------- ...istBytesToPrefixedHexStringSerializer.java | 26 ----------------- .../serializer/TokenSymbolSerializer.java | 27 ++++++++++++++++++ 9 files changed, 39 insertions(+), 71 deletions(-) rename src/main/java/com/binance/dex/api/client/crosschain/{Bep2TokenSymbol.java => TokenSymbol.java} (72%) delete mode 100644 src/main/java/com/binance/dex/api/client/encoding/serializer/Bep2TokenSymbolSerializer.java delete mode 100644 src/main/java/com/binance/dex/api/client/encoding/serializer/ListBytesToPrefixedHexStringSerializer.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/serializer/TokenSymbolSerializer.java diff --git a/src/main/java/com/binance/dex/api/client/crosschain/Bep2TokenSymbol.java b/src/main/java/com/binance/dex/api/client/crosschain/TokenSymbol.java similarity index 72% rename from src/main/java/com/binance/dex/api/client/crosschain/Bep2TokenSymbol.java rename to src/main/java/com/binance/dex/api/client/crosschain/TokenSymbol.java index 16d1369..ffbe2c3 100644 --- a/src/main/java/com/binance/dex/api/client/crosschain/Bep2TokenSymbol.java +++ b/src/main/java/com/binance/dex/api/client/crosschain/TokenSymbol.java @@ -1,7 +1,7 @@ package com.binance.dex.api.client.crosschain; import com.binance.dex.api.client.encoding.ByteUtil; -import com.binance.dex.api.client.encoding.serializer.Bep2TokenSymbolSerializer; +import com.binance.dex.api.client.encoding.serializer.TokenSymbolSerializer; import com.binance.dex.api.client.rlp.RlpDecodable; import com.fasterxml.jackson.databind.annotation.JsonSerialize; import lombok.Getter; @@ -9,8 +9,8 @@ @Getter @Setter -@JsonSerialize(using = Bep2TokenSymbolSerializer.class) -public class Bep2TokenSymbol implements RlpDecodable { +@JsonSerialize(using = TokenSymbolSerializer.class) +public class TokenSymbol implements RlpDecodable { private byte[] raw; private String symbol; diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/ApproveBindSyn.java b/src/main/java/com/binance/dex/api/client/crosschain/content/ApproveBindSyn.java index 1a6b974..740e759 100644 --- a/src/main/java/com/binance/dex/api/client/crosschain/content/ApproveBindSyn.java +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/ApproveBindSyn.java @@ -1,6 +1,6 @@ package com.binance.dex.api.client.crosschain.content; -import com.binance.dex.api.client.crosschain.Bep2TokenSymbol; +import com.binance.dex.api.client.crosschain.TokenSymbol; import com.binance.dex.api.client.crosschain.Content; import com.binance.dex.api.client.crosschain.UnsignedInt; import lombok.Getter; @@ -13,7 +13,7 @@ public class ApproveBindSyn extends Content { private UnsignedInt status; - private Bep2TokenSymbol symbol; + private TokenSymbol symbol; @Override protected void setHrp(String hrp) { diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/BindSyn.java b/src/main/java/com/binance/dex/api/client/crosschain/content/BindSyn.java index bb20cd9..0241b99 100644 --- a/src/main/java/com/binance/dex/api/client/crosschain/content/BindSyn.java +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/BindSyn.java @@ -2,20 +2,15 @@ import com.binance.dex.api.client.crosschain.*; import com.binance.dex.api.client.encoding.message.common.EthAddressValue; -import com.binance.dex.api.client.encoding.serializer.Bep2TokenSymbolSerializer; -import com.binance.dex.api.client.encoding.serializer.BytesToPrefixedHexStringSerializer; -import com.fasterxml.jackson.databind.annotation.JsonSerialize; import lombok.Getter; import lombok.Setter; -import java.math.BigInteger; - @Getter @Setter public class BindSyn extends Content { private UnsignedInt packageType; - private Bep2TokenSymbol symbol; + private TokenSymbol symbol; private EthAddressValue contractAddr; private UnsignedNumber totalSupply; private UnsignedNumber peggyAmount; diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/TransferInSyn.java b/src/main/java/com/binance/dex/api/client/crosschain/content/TransferInSyn.java index 39ab1e5..8ca4a0b 100644 --- a/src/main/java/com/binance/dex/api/client/crosschain/content/TransferInSyn.java +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/TransferInSyn.java @@ -1,6 +1,6 @@ package com.binance.dex.api.client.crosschain.content; -import com.binance.dex.api.client.crosschain.Bep2TokenSymbol; +import com.binance.dex.api.client.crosschain.TokenSymbol; import com.binance.dex.api.client.crosschain.Content; import com.binance.dex.api.client.crosschain.UnsignedLong; import com.binance.dex.api.client.crosschain.UnsignedNumber; @@ -15,7 +15,7 @@ @Setter public class TransferInSyn extends Content { - private Bep2TokenSymbol symbol; + private TokenSymbol symbol; private EthAddressValue contractAddress; private List amounts; private List receiverAddresses; diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/TransferOutRefund.java b/src/main/java/com/binance/dex/api/client/crosschain/content/TransferOutRefund.java index 75ad96f..e88ed92 100644 --- a/src/main/java/com/binance/dex/api/client/crosschain/content/TransferOutRefund.java +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/TransferOutRefund.java @@ -1,6 +1,6 @@ package com.binance.dex.api.client.crosschain.content; -import com.binance.dex.api.client.crosschain.Bep2TokenSymbol; +import com.binance.dex.api.client.crosschain.TokenSymbol; import com.binance.dex.api.client.crosschain.Content; import com.binance.dex.api.client.crosschain.UnsignedInt; import com.binance.dex.api.client.crosschain.UnsignedNumber; @@ -13,7 +13,7 @@ @Setter public class TransferOutRefund extends Content { - private Bep2TokenSymbol symbol; + private TokenSymbol symbol; private UnsignedNumber refundAmount; private Bech32AddressValue refundAddr; private UnsignedInt refundReason; diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/TransferOutSyn.java b/src/main/java/com/binance/dex/api/client/crosschain/content/TransferOutSyn.java index 4ad1942..7cc19de 100644 --- a/src/main/java/com/binance/dex/api/client/crosschain/content/TransferOutSyn.java +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/TransferOutSyn.java @@ -1,6 +1,6 @@ package com.binance.dex.api.client.crosschain.content; -import com.binance.dex.api.client.crosschain.Bep2TokenSymbol; +import com.binance.dex.api.client.crosschain.TokenSymbol; import com.binance.dex.api.client.crosschain.Content; import com.binance.dex.api.client.crosschain.UnsignedLong; import com.binance.dex.api.client.crosschain.UnsignedNumber; @@ -13,7 +13,7 @@ @Setter public class TransferOutSyn extends Content { - private Bep2TokenSymbol symbol; + private TokenSymbol symbol; private Bech32AddressValue contractAddress; private UnsignedNumber amount; private Bech32AddressValue recipient; diff --git a/src/main/java/com/binance/dex/api/client/encoding/serializer/Bep2TokenSymbolSerializer.java b/src/main/java/com/binance/dex/api/client/encoding/serializer/Bep2TokenSymbolSerializer.java deleted file mode 100644 index 250da29..0000000 --- a/src/main/java/com/binance/dex/api/client/encoding/serializer/Bep2TokenSymbolSerializer.java +++ /dev/null @@ -1,28 +0,0 @@ -package com.binance.dex.api.client.encoding.serializer; - -import com.binance.dex.api.client.crosschain.Bep2TokenSymbol; -import com.fasterxml.jackson.core.JsonGenerator; -import com.fasterxml.jackson.databind.JsonSerializer; -import com.fasterxml.jackson.databind.SerializerProvider; -import com.fasterxml.jackson.databind.ser.std.StdSerializer; -import org.apache.commons.lang3.StringUtils; - -import java.io.IOException; - -public class Bep2TokenSymbolSerializer extends StdSerializer { - - protected Bep2TokenSymbolSerializer(){ - this(null); - } - - protected Bep2TokenSymbolSerializer(Class t) { - super(t); - } - - @Override - public void serialize(Bep2TokenSymbol bep2TokenSymbol, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { - if (bep2TokenSymbol != null && StringUtils.isNotBlank(bep2TokenSymbol.getSymbol())){ - jsonGenerator.writeString(bep2TokenSymbol.getSymbol()); - } - } -} diff --git a/src/main/java/com/binance/dex/api/client/encoding/serializer/ListBytesToPrefixedHexStringSerializer.java b/src/main/java/com/binance/dex/api/client/encoding/serializer/ListBytesToPrefixedHexStringSerializer.java deleted file mode 100644 index 0e18394..0000000 --- a/src/main/java/com/binance/dex/api/client/encoding/serializer/ListBytesToPrefixedHexStringSerializer.java +++ /dev/null @@ -1,26 +0,0 @@ -package com.binance.dex.api.client.encoding.serializer; - -import com.binance.dex.api.client.encoding.EncodeUtils; -import com.fasterxml.jackson.core.JsonGenerator; -import com.fasterxml.jackson.databind.JsonSerializer; -import com.fasterxml.jackson.databind.SerializerProvider; - -import java.io.IOException; -import java.util.List; -import java.util.stream.Collectors; - -public class ListBytesToPrefixedHexStringSerializer extends JsonSerializer> { - - @Override - public void serialize(List bytesList, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { - if (bytesList != null){ - List list = bytesList.stream().map(item -> { - if (item != null) { - return EncodeUtils.bytesToPrefixHex(item); - } - return ""; - }).collect(Collectors.toList()); - jsonGenerator.writeObject(list); - } - } -} diff --git a/src/main/java/com/binance/dex/api/client/encoding/serializer/TokenSymbolSerializer.java b/src/main/java/com/binance/dex/api/client/encoding/serializer/TokenSymbolSerializer.java new file mode 100644 index 0000000..f093829 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/serializer/TokenSymbolSerializer.java @@ -0,0 +1,27 @@ +package com.binance.dex.api.client.encoding.serializer; + +import com.binance.dex.api.client.crosschain.TokenSymbol; +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.databind.SerializerProvider; +import com.fasterxml.jackson.databind.ser.std.StdSerializer; +import org.apache.commons.lang3.StringUtils; + +import java.io.IOException; + +public class TokenSymbolSerializer extends StdSerializer { + + protected TokenSymbolSerializer(){ + this(null); + } + + protected TokenSymbolSerializer(Class t) { + super(t); + } + + @Override + public void serialize(TokenSymbol tokenSymbol, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { + if (tokenSymbol != null && StringUtils.isNotBlank(tokenSymbol.getSymbol())){ + jsonGenerator.writeString(tokenSymbol.getSymbol()); + } + } +} From bfa9217583f550abef4efa6ddf9c7fa11e96f383 Mon Sep 17 00:00:00 2001 From: "fletcher.fan" Date: Thu, 23 Jul 2020 10:42:11 +0800 Subject: [PATCH 16/52] add proposal types for side chain proposal --- .../java/com/binance/dex/api/client/domain/ProposalType.java | 4 +++- .../binance/dex/api/client/examples/NodeClientExample.java | 4 ++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/src/main/java/com/binance/dex/api/client/domain/ProposalType.java b/src/main/java/com/binance/dex/api/client/domain/ProposalType.java index 889179f..57b06e9 100644 --- a/src/main/java/com/binance/dex/api/client/domain/ProposalType.java +++ b/src/main/java/com/binance/dex/api/client/domain/ProposalType.java @@ -14,7 +14,9 @@ public enum ProposalType { FeeChange(5L), CreateValidator(6L), RemoveValidator(7L), - DelistTradingPair(8L); + DelistTradingPair(8L), + SideChainParamsChange(129L), + CrossSideChainParamsChange(130L); private long value; diff --git a/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java b/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java index c3737a1..f6a4157 100644 --- a/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java +++ b/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java @@ -232,9 +232,9 @@ public void testNodeInfo() { @Test public void testGetTransaction() { - Transaction transaction = binanceDexNodeApi.getTransaction("8B13490FB57C4650CE68E09E51C768D76A15B00FE5E5898D9453EF9B7162DB82"); + Transaction transaction = binanceDexNodeApi.getTransaction("1218DC0B64E3A128790AD8697CC9EC19F840D1D4202A5FA6EC64C4424793F5F0"); Assert.assertNotNull(transaction); - Assert.assertEquals("8B13490FB57C4650CE68E09E51C768D76A15B00FE5E5898D9453EF9B7162DB82", transaction.getHash()); + Assert.assertEquals("1218DC0B64E3A128790AD8697CC9EC19F840D1D4202A5FA6EC64C4424793F5F0", transaction.getHash()); Assert.assertEquals(0, transaction.getCode().intValue()); } From 30c8e48b269a508ef3de432bdb226e9c058fe987 Mon Sep 17 00:00:00 2001 From: "fletcher.fan" Date: Thu, 13 Aug 2020 13:46:50 +0800 Subject: [PATCH 17/52] convert eth address to checksum address --- .../api/client/BinanceDexApiNodeClient.java | 6 ----- .../dex/api/client/encoding/EncodeUtils.java | 21 ++++++++++++++++ .../message/common/EthAddressValue.java | 20 +++++++++++++++- .../impl/BinanceDexApiNodeClientImpl.java | 24 ------------------- 4 files changed, 40 insertions(+), 31 deletions(-) diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java b/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java index 466673e..4829ee0 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java @@ -273,16 +273,10 @@ default List unfreeze(TokenUnfreeze unfreeze, Wallet wallet long getCurrentSequence(int claimType); - List transferIn(long sequence, TransferIn transferIn, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; - List transferOut(String toAddress, com.binance.dex.api.client.encoding.message.Token amount, long expireTimeInSeconds, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; List bind(String symbol, long amount, String contractAddress, int contractDecimal, long expireTimeInSeconds, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; List unBind(String symbol, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; - List updateTransferOut(long sequence, String refundAddress, com.binance.dex.api.client.encoding.message.Token amount, int refundReason, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; - - List updateBind(long sequence, String symbol, String contractAddress, int status, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; - } diff --git a/src/main/java/com/binance/dex/api/client/encoding/EncodeUtils.java b/src/main/java/com/binance/dex/api/client/encoding/EncodeUtils.java index cb9327a..8a24a04 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/EncodeUtils.java +++ b/src/main/java/com/binance/dex/api/client/encoding/EncodeUtils.java @@ -4,11 +4,13 @@ import com.fasterxml.jackson.databind.ObjectMapper; import com.google.common.base.Charsets; import com.google.protobuf.CodedOutputStream; +import org.bouncycastle.jcajce.provider.digest.Keccak; import org.bouncycastle.util.encoders.Hex; import java.io.IOException; import java.nio.ByteBuffer; import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; import java.security.MessageDigest; public class EncodeUtils { @@ -30,6 +32,13 @@ public static String bytesToPrefixHex(byte[] bytes) { return "0x" + bytesToHex(bytes); } + public static String cleanHexPrefix(String s){ + if (s.startsWith("0x")){ + s = s.substring(2); + } + return s; + } + public static String toJsonStringSortKeys(Object object) throws JsonProcessingException { return OBJECT_MAPPER.writeValueAsString(object); } @@ -77,4 +86,16 @@ public static ObjectMapper getObjectMapper() { return OBJECT_MAPPER; } + public static String sha3String(String utf8String) { + return bytesToHex(sha3(utf8String.getBytes(StandardCharsets.UTF_8))); + } + public static byte[] sha3(byte[] input) { + return sha3(input, 0, input.length); + } + public static byte[] sha3(byte[] input, int offset, int length) { + Keccak.DigestKeccak kecc = new Keccak.Digest256(); + kecc.update(input, offset, length); + return kecc.digest(); + } + } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/common/EthAddressValue.java b/src/main/java/com/binance/dex/api/client/encoding/message/common/EthAddressValue.java index bb9506e..e7ceefe 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/common/EthAddressValue.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/common/EthAddressValue.java @@ -1,5 +1,6 @@ package com.binance.dex.api.client.encoding.message.common; +import com.binance.dex.api.client.encoding.EncodeUtils; import com.binance.dex.api.client.encoding.amino.AminoCustomSerialized; import com.binance.dex.api.client.encoding.amino.WireType; import com.binance.dex.api.client.encoding.serializer.EthAddressValueToStringSerializer; @@ -21,7 +22,7 @@ public class EthAddressValue implements AminoCustomSerialized, RlpDecodable { private String address; public static EthAddressValue from(String addr){ - return new EthAddressValue(addr); + return new EthAddressValue(toChecksumAddress(addr)); } public EthAddressValue() { @@ -88,4 +89,21 @@ public void decode(byte[] raw, Object superInstance) { address = Hex.toHexString(raw); address = "0x" + address; } + + public static String toChecksumAddress(String address) { + String lowercaseAddress = EncodeUtils.cleanHexPrefix(address).toLowerCase(); + String addressHash = EncodeUtils.cleanHexPrefix(EncodeUtils.sha3String(lowercaseAddress)); + StringBuilder result = new StringBuilder(lowercaseAddress.length() + 2); + result.append("0x"); + + for(int i = 0; i < lowercaseAddress.length(); ++i) { + if (Integer.parseInt(String.valueOf(addressHash.charAt(i)), 16) >= 8) { + result.append(String.valueOf(lowercaseAddress.charAt(i)).toUpperCase()); + } else { + result.append(lowercaseAddress.charAt(i)); + } + } + + return result.toString(); + } } diff --git a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java index a7940ff..b8fd8e6 100644 --- a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java +++ b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java @@ -503,14 +503,6 @@ public List sideVote(SideVote vote, Wallet wallet, Transact } } - @Override - public List transferIn(long sequence, TransferIn transferIn, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { - synchronized (wallet) { - wallet.ensureWalletIsReady(this); - return bridgeTxDelegate.transferIn(sequence, transferIn, wallet, options, sync); - } - } - @Override public List transferOut(String toAddress, com.binance.dex.api.client.encoding.message.Token amount, long expireTimeInSeconds, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { synchronized (wallet) { @@ -535,22 +527,6 @@ public List unBind(String symbol, Wallet wallet, Transactio } } - @Override - public List updateTransferOut(long sequence, String refundAddress, com.binance.dex.api.client.encoding.message.Token amount, int refundReason, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { - synchronized (wallet) { - wallet.ensureWalletIsReady(this); - return bridgeTxDelegate.updateTransferOut(sequence, refundAddress, amount, refundReason, wallet, options, sync); - } - } - - @Override - public List updateBind(long sequence, String symbol, String contractAddress, int status, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { - synchronized (wallet) { - wallet.ensureWalletIsReady(this); - return bridgeTxDelegate.updateBind(sequence, symbol, contractAddress, status, wallet, options, sync); - } - } - @Override public List claim(int chainId, byte[] payload, long sequence, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { synchronized (wallet) { From e3376704ce1fb43f9b60402b243a812efdbd9f9d Mon Sep 17 00:00:00 2001 From: "fletcher.fan" Date: Thu, 13 Aug 2020 13:47:49 +0800 Subject: [PATCH 18/52] remove used function --- .../client/examples/BridgeNodeExample.java | 57 ------------------- 1 file changed, 57 deletions(-) diff --git a/src/test/java/com/binance/dex/api/client/examples/BridgeNodeExample.java b/src/test/java/com/binance/dex/api/client/examples/BridgeNodeExample.java index 7731936..8fc2a96 100644 --- a/src/test/java/com/binance/dex/api/client/examples/BridgeNodeExample.java +++ b/src/test/java/com/binance/dex/api/client/examples/BridgeNodeExample.java @@ -81,37 +81,6 @@ public void t() throws JsonProcessingException { System.out.println(EncodeUtils.toJsonStringSortKeys(packages)); } - @Test - public void transferIn() throws IOException, NoSuchAlgorithmException { - TransferIn transferIn = new TransferIn(); - transferIn.setContractAddress("0xd1B22dCC24C55f4d728E7aaA5c9b5a22e1512C08"); - - List refundAddresses = new ArrayList<>(); - refundAddresses.add("0x9fB29AAc15b9A4B7F17c3385939b007540f4d791"); - transferIn.setRefundAddresses(refundAddresses); - - List receiverAddresses = new ArrayList<>(); - receiverAddresses.add(wallet.getAddress()); - transferIn.setReceiverAddresses(receiverAddresses); - - List amounts = new ArrayList<>(); - amounts.add(100000L); - transferIn.setAmounts(amounts); - - transferIn.setSymbol("BNB"); - - transferIn.setRelayFee(new Token("BNB", 10L)); - - transferIn.setExpireTime((System.currentTimeMillis() + 1000 * 60 * 60 * 24 * 3) / 1000); - - TransactionOption options = new TransactionOption("", 0, null); - - long sequence = nodeClient.getCurrentSequence(ClaimTypes.ClaimTypeTransferIn); - - List results = nodeClient.transferIn(sequence, transferIn, wallet, options, true); - Assert.assertEquals(1, results.size()); - } - @Test public void transferOut() throws IOException, NoSuchAlgorithmException { String toAddress = "0x9fB29AAc15b9A4B7F17c3385939b007540f4d791"; @@ -148,32 +117,6 @@ public void unBind() throws IOException, NoSuchAlgorithmException { Assert.assertTrue(results.get(0).isOk()); } - @Test - public void updateTransferOut() throws IOException, NoSuchAlgorithmException { - long sequence = nodeClient.getCurrentSequence(ClaimTypes.ClaimTypeUpdateTransferOut); - String refundAddress = wallet.getAddress(); - Token amount = new Token("BNB", 100000L); - int refundReason = RefundReason.timeout; - - TransactionOption options = new TransactionOption("", 0, null); - - List results = nodeClient.updateTransferOut(sequence, refundAddress, amount, refundReason, wallet, options, true); - Assert.assertEquals(1, results.size()); - } - - @Test - public void updateBind() throws IOException, NoSuchAlgorithmException { - long sequence = nodeClient.getCurrentSequence(ClaimTypes.ClaimTypeUpdateBind); - String symbol = "BNB"; - String contractAddress = "0xd1B22dCC24C55f4d728E7aaA5c9b5a22e1512C08"; - int status = BindStatus.bindStatusSuccess; - - TransactionOption options = new TransactionOption("", 0, null); - - List results = nodeClient.updateBind(sequence, symbol, contractAddress, status, wallet, options, true); - Assert.assertEquals(1, results.size()); - } - @Test public void claim() throws IOException, NoSuchAlgorithmException { TransactionOption options = new TransactionOption("", 0, null); From a20d720871f7e64767a435be59b69c096c65d1e5 Mon Sep 17 00:00:00 2001 From: "fletcher.fan" Date: Sat, 22 Aug 2020 15:21:34 +0800 Subject: [PATCH 19/52] change to bva --- .../java/com/binance/dex/api/client/BinanceDexEnvironment.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexEnvironment.java b/src/main/java/com/binance/dex/api/client/BinanceDexEnvironment.java index e835fbf..3fb1e96 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexEnvironment.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexEnvironment.java @@ -18,7 +18,7 @@ public class BinanceDexEnvironment { "http://data-seed-pre-0-s3.binance.org", "wss://data-seed-pre-0-s3.binance.org/websocket", "tbnb", - "tbva" + "bva" ); // Rest API base URL From 1e714d270e96ffc75bf053e9f162dd2f65414595 Mon Sep 17 00:00:00 2001 From: "fletcher.fan" Date: Sat, 22 Aug 2020 15:32:44 +0800 Subject: [PATCH 20/52] ingore testClaim() --- pom.xml | 37 ++++++++++++++++++- .../dex/api/client/encoding/AminoTest.java | 1 - 2 files changed, 36 insertions(+), 2 deletions(-) diff --git a/pom.xml b/pom.xml index 253e3e2..60bdb1d 100644 --- a/pom.xml +++ b/pom.xml @@ -5,7 +5,7 @@ com.binance.dex.api binance-dex-api-client - 1.1.0 + 1.1.0-SNAPSHOT 2.6.0 @@ -161,5 +161,40 @@ + + + + + dev + + + bijie-releases + Internal Releases + http://nexus.k8s.qa1fdg.net/repository/maven-releases + + + bijie-snapshots + Internal Releases + http://nexus.k8s.qa1fdg.net/repository/maven-snapshots + + + + + + server + + + bijie-releases + Internal Releases + http://10.99.41.221:8081/repository/maven-releases + + + bijie-snapshots + Internal Releases + http://10.99.41.221:8081/repository/maven-snapshots + + + + \ No newline at end of file diff --git a/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java b/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java index 7384156..8d91392 100644 --- a/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java +++ b/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java @@ -40,7 +40,6 @@ public void testDecodeRedelegation() throws IOException { Assert.assertNotNull(value.getSharesDst()); } - @Test public void testClaim() throws IOException { ClaimMsgMessage message = new ClaimMsgMessage(); message.setChainId(ClaimTypes.ClaimTypeTransferIn); From 299beae9770a5e443bb5bb66de6a10b9bded0698 Mon Sep 17 00:00:00 2001 From: "fletcher.fan" Date: Tue, 25 Aug 2020 19:24:42 +0800 Subject: [PATCH 21/52] version fix --- pom.xml | 36 +----------------------------------- 1 file changed, 1 insertion(+), 35 deletions(-) diff --git a/pom.xml b/pom.xml index 60bdb1d..df87fbc 100644 --- a/pom.xml +++ b/pom.xml @@ -5,7 +5,7 @@ com.binance.dex.api binance-dex-api-client - 1.1.0-SNAPSHOT + 1.1.0 2.6.0 @@ -163,38 +163,4 @@ - - - - dev - - - bijie-releases - Internal Releases - http://nexus.k8s.qa1fdg.net/repository/maven-releases - - - bijie-snapshots - Internal Releases - http://nexus.k8s.qa1fdg.net/repository/maven-snapshots - - - - - - server - - - bijie-releases - Internal Releases - http://10.99.41.221:8081/repository/maven-releases - - - bijie-snapshots - Internal Releases - http://10.99.41.221:8081/repository/maven-snapshots - - - - \ No newline at end of file From d387f7a223e66809afd1528496e2549877b76f93 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 13 Oct 2020 11:57:43 +0000 Subject: [PATCH 22/52] Bump junit from 4.12 to 4.13.1 Bumps [junit](https://github.com/junit-team/junit4) from 4.12 to 4.13.1. - [Release notes](https://github.com/junit-team/junit4/releases) - [Changelog](https://github.com/junit-team/junit4/blob/main/doc/ReleaseNotes4.12.md) - [Commits](https://github.com/junit-team/junit4/compare/r4.12...r4.13.1) Signed-off-by: dependabot[bot] --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index df87fbc..1c38ee3 100644 --- a/pom.xml +++ b/pom.xml @@ -70,7 +70,7 @@ junit junit - 4.12 + 4.13.1 test From 8650ba5e12852a71a5e247f8d059f073acf8d786 Mon Sep 17 00:00:00 2001 From: "fletcher.fan" Date: Thu, 17 Dec 2020 15:48:32 +0800 Subject: [PATCH 23/52] add transferOwnership transaction --- .../api/client/BinanceDexApiRestClient.java | 3 + .../dex/api/client/TransactionConverter.java | 17 ++++ .../client/domain/TransferTokenOwnership.java | 32 ++++++++ .../api/client/domain/broadcast/TxType.java | 1 + .../client/encoding/message/MessageType.java | 1 + .../message/TransactionRequestAssembler.java | 79 +++++++++++++------ .../TransferTokenOwnershipMessage.java | 39 +++++++++ .../impl/BinanceDexApiNodeClientImpl.java | 14 ++++ .../impl/BinanceDexApiRestClientImpl.java | 9 +++ src/main/proto/dex.proto | 7 ++ 10 files changed, 177 insertions(+), 25 deletions(-) create mode 100644 src/main/java/com/binance/dex/api/client/domain/TransferTokenOwnership.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/TransferTokenOwnershipMessage.java diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexApiRestClient.java b/src/main/java/com/binance/dex/api/client/BinanceDexApiRestClient.java index d9d97c4..7fafa8f 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexApiRestClient.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexApiRestClient.java @@ -120,5 +120,8 @@ List claimHtlt(String swapId,byte[] randomNumber,Wallet wal List refundHtlt(String swapId,Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; + List transferTokenOwnership(String symbol, String newOwner, Wallet wallet, TransactionOption options, boolean sync) + throws IOException, NoSuchAlgorithmException; + List broadcast(String payload,boolean sync); } diff --git a/src/main/java/com/binance/dex/api/client/TransactionConverter.java b/src/main/java/com/binance/dex/api/client/TransactionConverter.java index 6bce540..c4aa533 100644 --- a/src/main/java/com/binance/dex/api/client/TransactionConverter.java +++ b/src/main/java/com/binance/dex/api/client/TransactionConverter.java @@ -171,6 +171,8 @@ public Transaction convert(byte[] bytes) { return convertBurn(bytes); case Mint: return convertMint(bytes); + case TransferTokenOwnership: + return convertTransferTokenOwnership(bytes); case SubmitProposal: return convertSubmitProposal(bytes); case SideSubmitProposal: @@ -239,6 +241,21 @@ public Transaction convert(byte[] bytes) { } } + private Transaction convertTransferTokenOwnership(byte[] value) throws IOException { + byte[] raw = ByteUtil.cut(value, 4); + TransferTokenOwnershipMsg msg = TransferTokenOwnershipMsg.parseFrom(raw); + + TransferTokenOwnership transferTokenOwnership = new TransferTokenOwnership(); + transferTokenOwnership.setFrom(Crypto.encodeAddress(hrp, msg.getFrom().toByteArray())); + transferTokenOwnership.setSymbol(msg.getSymbol()); + transferTokenOwnership.setNewOwner(Crypto.encodeAddress(hrp, msg.getNewOwner().toByteArray())); + + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.TRANSFER_TOKEN_OWNERSHIP); + transaction.setRealTx(transferTokenOwnership); + return transaction; + } + private Transaction convertSideChainUnJail(byte[] value) throws IOException { byte[] raw = ByteUtil.cut(value, 4); SideChainUnJailMsg message = SideChainUnJailMsg.parseFrom(raw); diff --git a/src/main/java/com/binance/dex/api/client/domain/TransferTokenOwnership.java b/src/main/java/com/binance/dex/api/client/domain/TransferTokenOwnership.java new file mode 100644 index 0000000..910c924 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/TransferTokenOwnership.java @@ -0,0 +1,32 @@ +package com.binance.dex.api.client.domain; + + +public class TransferTokenOwnership { + private String from; + private String symbol; + private String newOwner; + + public String getFrom() { + return from; + } + + public void setFrom(String from) { + this.from = from; + } + + public String getSymbol() { + return symbol; + } + + public void setSymbol(String symbol) { + this.symbol = symbol; + } + + public String getNewOwner() { + return newOwner; + } + + public void setNewOwner(String newOwner) { + this.newOwner = newOwner; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java b/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java index e49b9fb..d63a67c 100644 --- a/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java +++ b/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java @@ -11,6 +11,7 @@ public enum TxType { ISSUE, BURN, MINT, + TRANSFER_TOKEN_OWNERSHIP, SUBMIT_PROPOSAL, SIDE_SUBMIT_PROPOSAL, DEPOSIT, diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java b/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java index 19decf9..bafa81e 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java @@ -21,6 +21,7 @@ public enum MessageType { Issue("17EFAB80"), Burn("7ED2D2A0"), Mint("467E0829"), + TransferTokenOwnership("6D99D273"), SubmitProposal("B42D614E"), SideSubmitProposal("4ACBF03C"), Deposit("A18A56E5"), diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/TransactionRequestAssembler.java b/src/main/java/com/binance/dex/api/client/encoding/message/TransactionRequestAssembler.java index 16b134e..ab1e0e4 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/TransactionRequestAssembler.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/TransactionRequestAssembler.java @@ -10,6 +10,7 @@ import com.binance.dex.api.client.encoding.amino.WireType; import com.binance.dex.api.proto.StdSignature; import com.binance.dex.api.proto.StdTx; +import com.binance.dex.api.proto.TransferTokenOwnershipMsg; import com.google.common.annotations.VisibleForTesting; import com.google.protobuf.ByteString; import okhttp3.RequestBody; @@ -61,14 +62,14 @@ byte[] signTx(BinanceDexTransactionMessage msg) throws IOException, NoSuchAlgori return sign(assembleMessage4Sign(msg)); } - private BinanceDexTransactionMessage assembleMessage4Sign(T t){ - if (t.useAminoJson()){ - if (WireType.isRegistered(t.getClass())){ + private BinanceDexTransactionMessage assembleMessage4Sign(T t) { + if (t.useAminoJson()) { + if (WireType.isRegistered(t.getClass())) { return new TransactionMessageWithType(WireType.getRegisteredTypeName(t.getClass()), t); - }else{ + } else { throw new IllegalStateException("Class " + t.getClass().getCanonicalName() + " has not been registered into amino"); } - }else{ + } else { return t; } } @@ -142,7 +143,7 @@ NewOrderMessage createNewOrderMessage( } @VisibleForTesting - VoteMessage createVoteMessage(Vote vote){ + VoteMessage createVoteMessage(Vote vote) { VoteMessage voteMessage = new VoteMessage(); voteMessage.setProposalId(vote.getProposalId()); voteMessage.setOption(vote.getOption()); @@ -151,7 +152,7 @@ VoteMessage createVoteMessage(Vote vote){ } @VisibleForTesting - SideVoteMessage createSideVoteMessage(SideVote vote){ + SideVoteMessage createSideVoteMessage(SideVote vote) { SideVoteMessage voteMessage = new SideVoteMessage(); voteMessage.setProposalId(vote.getProposalId()); voteMessage.setOption(vote.getOption()); @@ -205,7 +206,7 @@ public RequestBody buildNewOrder(com.binance.dex.api.client.domain.broadcast.New } public String buildNewOrderPayload(com.binance.dex.api.client.domain.broadcast.NewOrder newOrder) - throws IOException, NoSuchAlgorithmException { + throws IOException, NoSuchAlgorithmException { NewOrderMessage msgBean = createNewOrderMessage(newOrder); byte[] msg = encodeNewOrderMessage(msgBean); byte[] signature = encodeSignature(sign(msgBean)); @@ -265,7 +266,7 @@ public RequestBody buildCancelOrder(com.binance.dex.api.client.domain.broadcast. } public String buildCancelOrderPayload(com.binance.dex.api.client.domain.broadcast.CancelOrder cancelOrder) - throws IOException, NoSuchAlgorithmException { + throws IOException, NoSuchAlgorithmException { CancelOrderMessage msgBean = createCancelOrderMessage(cancelOrder); byte[] msg = encodeCancelOrderMessage(msgBean); byte[] signature = encodeSignature(sign(msgBean)); @@ -341,7 +342,7 @@ public RequestBody buildTransfer(Transfer transfer) } public String buildTransferPayload(Transfer transfer) - throws IOException, NoSuchAlgorithmException { + throws IOException, NoSuchAlgorithmException { TransferMessage msgBean = createTransferMessage(transfer); byte[] msg = encodeTransferMessage(msgBean); byte[] signature = encodeSignature(sign(msgBean)); @@ -375,7 +376,7 @@ public RequestBody buildTokenFreeze(TokenFreeze freeze) } public String buildTokenFreezePayload(TokenFreeze freeze) - throws IOException, NoSuchAlgorithmException { + throws IOException, NoSuchAlgorithmException { TokenFreezeMessage msgBean = createTokenFreezeMessage(freeze); byte[] msg = encodeTokenFreezeMessage(msgBean); byte[] signature = encodeSignature(sign(msgBean)); @@ -409,7 +410,7 @@ public RequestBody buildTokenUnfreeze(TokenUnfreeze unfreeze) } public String buildTokenUnfreezePayload(TokenUnfreeze unfreeze) - throws IOException, NoSuchAlgorithmException { + throws IOException, NoSuchAlgorithmException { TokenUnfreezeMessage msgBean = createTokenUnfreezeMessage(unfreeze); byte[] msg = encodeTokenUnfreezeMessage(msgBean); byte[] signature = encodeSignature(sign(msgBean)); @@ -421,11 +422,11 @@ public String buildTokenUnfreezePayload(TokenUnfreeze unfreeze) TransferMessage createMultiTransferMessage(MultiTransfer multiTransfer) { Map inputsCoins = new TreeMap(); ArrayList outputs = new ArrayList<>(); - for (Output o: multiTransfer.getOutputs()) { + for (Output o : multiTransfer.getOutputs()) { InputOutput out = new InputOutput(); out.setAddress(o.getAddress()); List tokens = new ArrayList<>(o.getTokens().size()); - for (OutputToken t: o.getTokens()) { + for (OutputToken t : o.getTokens()) { Token token = new Token(); token.setDenom(t.getCoin()); long amount = doubleToLong(t.getAmount()); @@ -447,7 +448,7 @@ TransferMessage createMultiTransferMessage(MultiTransfer multiTransfer) { InputOutput input = new InputOutput(); input.setAddress(multiTransfer.getFromAddress()); List inputTokens = new ArrayList<>(inputsCoins.size()); - for (String coin: inputsCoins.keySet()) { + for (String coin : inputsCoins.keySet()) { Token token = new Token(); token.setDenom(coin); token.setAmount(inputsCoins.get(coin)); @@ -461,7 +462,7 @@ TransferMessage createMultiTransferMessage(MultiTransfer multiTransfer) { return msgBean; } - public RequestBody buildMultiTransfer(MultiTransfer multiTransfer) throws IOException, NoSuchAlgorithmException{ + public RequestBody buildMultiTransfer(MultiTransfer multiTransfer) throws IOException, NoSuchAlgorithmException { return createRequestBody(buildMultiTransferPayload(multiTransfer)); } @@ -488,7 +489,7 @@ public String buildHtltPayload(HtltReq htltReq) throws IOException, NoSuchAlgori } @VisibleForTesting - public HtltMessage createHtltMessage(HtltReq htltReq){ + public HtltMessage createHtltMessage(HtltReq htltReq) { HtltMessage message = new HtltMessage(); message.setFrom(wallet.getAddress()); message.setTo(htltReq.getRecipient()); @@ -515,7 +516,7 @@ byte[] encodeHtltMessage(HtltMessage msg) builder.setSenderOtherChain(msg.getSenderOtherChain()); builder.setRandomNumberHash(ByteString.copyFrom(msg.getRandomNumberHash())); builder.setTimestamp(msg.getTimestamp()); - for(Token token : msg.getAmount()){ + for (Token token : msg.getAmount()) { builder.addAmount(com.binance.dex.api.proto.Token.newBuilder().setAmount(token.getAmount()).setDenom(token.getDenom())); } builder.setExpectedIncome(msg.getExpectedIncome()); @@ -526,11 +527,11 @@ byte[] encodeHtltMessage(HtltMessage msg) } public RequestBody buildDepositHtlt(String swapId, List amount) throws IOException, NoSuchAlgorithmException { - return createRequestBody(buildDepositHtltPayload(swapId,amount)); + return createRequestBody(buildDepositHtltPayload(swapId, amount)); } public String buildDepositHtltPayload(String swapId, List amount) throws IOException, NoSuchAlgorithmException { - DepositHtltMessage depositHtltMessage = createDepositHtltMessage(swapId,amount); + DepositHtltMessage depositHtltMessage = createDepositHtltMessage(swapId, amount); byte[] msg = encodeDepositHtltMessage(depositHtltMessage); byte[] signature = encodeSignature(sign(depositHtltMessage)); byte[] stdTx = encodeStdTx(msg, signature); @@ -538,7 +539,7 @@ public String buildDepositHtltPayload(String swapId, List amount) throws } @VisibleForTesting - public DepositHtltMessage createDepositHtltMessage(String swapId, List amount){ + public DepositHtltMessage createDepositHtltMessage(String swapId, List amount) { DepositHtltMessage message = new DepositHtltMessage(); message.setFrom(wallet.getAddress()); message.setSwapId(swapId); @@ -553,7 +554,7 @@ public byte[] encodeDepositHtltMessage(DepositHtltMessage msg) com.binance.dex.api.proto.DepositHashTimerLockMsg.Builder builder = com.binance.dex.api.proto.DepositHashTimerLockMsg.newBuilder(); builder.setFrom(ByteString.copyFrom(address)); builder.setSwapId(ByteString.copyFrom(Hex.decode(msg.getSwapId()))); - for(Token token : msg.getAmount()){ + for (Token token : msg.getAmount()) { builder.addAmount(com.binance.dex.api.proto.Token.newBuilder().setAmount(token.getAmount()).setDenom(token.getDenom())); } com.binance.dex.api.proto.DepositHashTimerLockMsg proto = builder.build(); @@ -561,7 +562,7 @@ public byte[] encodeDepositHtltMessage(DepositHtltMessage msg) } public RequestBody buildClaimHtlt(String swapId, byte[] randomNumber) throws IOException, NoSuchAlgorithmException { - return createRequestBody(buildClaimHtltPayload(swapId,randomNumber)); + return createRequestBody(buildClaimHtltPayload(swapId, randomNumber)); } public String buildClaimHtltPayload(String swapId, byte[] randomNumber) throws IOException, NoSuchAlgorithmException { @@ -610,11 +611,39 @@ public byte[] encodeRefundHtltMessage(RefundHtltMessage msg) throws IOException return EncodeUtils.aminoWrap(proto.toByteArray(), MessageType.RefundHashTimerLockMsg.getTypePrefixBytes(), false); } + public RequestBody buildTransferTokenOwnership(String symbol, String newOwner) throws IOException, NoSuchAlgorithmException { + return createRequestBody(buildTransferTokenOwnershipPayload(symbol, newOwner)); + } + + public String buildTransferTokenOwnershipPayload(String symbol, String newOwner) throws IOException, NoSuchAlgorithmException { + TransferTokenOwnershipMessage message = new TransferTokenOwnershipMessage(); + message.setFrom(wallet.getAddress()); + message.setSymbol(symbol); + message.setNewOwner(newOwner); + byte[] msg = encodeTransferTokenOwnershipMessage(message); + byte[] signature = encodeSignature(sign(message)); + byte[] stdTx = encodeStdTx(msg, signature); + return EncodeUtils.bytesToHex(stdTx); + } + + @VisibleForTesting + public byte[] encodeTransferTokenOwnershipMessage(TransferTokenOwnershipMessage msg) throws IOException { + byte[] address = Crypto.decodeAddress(msg.getFrom()); + byte[] newOwnerB = Crypto.decodeAddress(msg.getNewOwner()); + TransferTokenOwnershipMsg.Builder builder = TransferTokenOwnershipMsg.newBuilder(); + builder.setFrom(ByteString.copyFrom(address)); + builder.setSymbol(msg.getSymbol()); + builder.setNewOwner(ByteString.copyFrom(newOwnerB)); + TransferTokenOwnershipMsg proto = builder.build(); + return EncodeUtils.aminoWrap(proto.toByteArray(), MessageType.TransferTokenOwnership.getTypePrefixBytes(), false); + } + + /** * Used for amino serializable message - * */ + */ public String buildTxPayload(BinanceDexTransactionMessage message) throws IOException, NoSuchAlgorithmException { - if (!AminoSerializable.class.isAssignableFrom(message.getClass())){ + if (!AminoSerializable.class.isAssignableFrom(message.getClass())) { throw new IllegalArgumentException("Class " + message.getClass() + " should also implement AminoSerializable to support amino encoding"); } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/TransferTokenOwnershipMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/TransferTokenOwnershipMessage.java new file mode 100644 index 0000000..ee25c9d --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/TransferTokenOwnershipMessage.java @@ -0,0 +1,39 @@ +package com.binance.dex.api.client.encoding.message; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class TransferTokenOwnershipMessage implements BinanceDexTransactionMessage { + + private String from; + private String symbol; + @JsonProperty("new_owner") + private String newOwner; + + public String getFrom() { + return from; + } + + public void setFrom(String from) { + this.from = from; + } + + public String getSymbol() { + return symbol; + } + + public void setSymbol(String symbol) { + this.symbol = symbol; + } + + public String getNewOwner() { + return newOwner; + } + + public void setNewOwner(String newOwner) { + this.newOwner = newOwner; + } +} diff --git a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java index b8fd8e6..e2312f4 100644 --- a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java +++ b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java @@ -389,6 +389,20 @@ public List refundHtlt(String swapId, Wallet wallet, Transa } } + @Override + public List transferTokenOwnership(String symbol, String newOwner, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + synchronized (wallet) { + wallet.ensureWalletIsReady(this); + TransactionRequestAssembler assembler = new TransactionRequestAssembler(wallet, options); + String requestPayload = "0x" + assembler.buildTransferTokenOwnershipPayload(symbol, newOwner); + if (sync) { + return syncBroadcast(requestPayload, wallet); + } else { + return asyncBroadcast(requestPayload, wallet); + } + } + } + @Override public List createSideChainValidator(CreateSideChainValidator createSideChainValidator, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { synchronized (wallet) { diff --git a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiRestClientImpl.java b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiRestClientImpl.java index 3b3501f..b090354 100644 --- a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiRestClientImpl.java +++ b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiRestClientImpl.java @@ -362,6 +362,15 @@ public List refundHtlt(String swapId, Wallet wallet, Transa return broadcast(requestBody, sync, wallet); } + @Override + public List transferTokenOwnership(String symbol, String newOwner, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + wallet.ensureWalletIsReady(this); + TransactionRequestAssembler assembler = new TransactionRequestAssembler(wallet, options); + RequestBody requestBody = assembler.buildTransferTokenOwnership(symbol, newOwner); + return broadcast(requestBody, sync, wallet); + } + + @Override public List broadcast(String payload, boolean sync) { try { diff --git a/src/main/proto/dex.proto b/src/main/proto/dex.proto index cce4e29..6e5fe01 100644 --- a/src/main/proto/dex.proto +++ b/src/main/proto/dex.proto @@ -462,4 +462,11 @@ message MiniTokenList { string base_asset_symbol = 2; string quote_asset_symbol = 3; int64 init_price = 4; +} + +message TransferTokenOwnershipMsg { + // 6d99d273 + bytes from = 1; + string symbol = 2; + bytes new_owner = 3; } \ No newline at end of file From ba690cb3c986af7e9445a75e1c97df67cec53448 Mon Sep 17 00:00:00 2001 From: "fletcher.fan" Date: Mon, 4 Jan 2021 13:46:02 +0800 Subject: [PATCH 24/52] upgrade version --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index df87fbc..76e35d7 100644 --- a/pom.xml +++ b/pom.xml @@ -5,7 +5,7 @@ com.binance.dex.api binance-dex-api-client - 1.1.0 + 1.1.1 2.6.0 From 82364851870628bda808bc89ce60801fa7400ff4 Mon Sep 17 00:00:00 2001 From: "fletcher.fan" Date: Tue, 5 Jan 2021 16:06:15 +0800 Subject: [PATCH 25/52] add new type of oracle claim --- .../api/client/crosschain/ContentEnum.java | 3 +++ .../client/crosschain/content/MirrorAck.java | 26 +++++++++++++++++++ .../client/crosschain/content/MirrorSyn.java | 25 ++++++++++++++++++ .../crosschain/content/MirrorSyncAck.java | 23 ++++++++++++++++ .../crosschain/content/MirrorSyncSyn.java | 26 +++++++++++++++++++ 5 files changed, 103 insertions(+) create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/content/MirrorAck.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/content/MirrorSyn.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/content/MirrorSyncAck.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/content/MirrorSyncSyn.java diff --git a/src/main/java/com/binance/dex/api/client/crosschain/ContentEnum.java b/src/main/java/com/binance/dex/api/client/crosschain/ContentEnum.java index 9cb6ce0..c6e5d05 100644 --- a/src/main/java/com/binance/dex/api/client/crosschain/ContentEnum.java +++ b/src/main/java/com/binance/dex/api/client/crosschain/ContentEnum.java @@ -19,6 +19,9 @@ public enum ContentEnum { IbcValidatorSetPack(8, 2, IbcValidatorSet.class), GovCommonAckPack(9, 1, CommonAck.class), SideDowntimeSlashPack(11, 0, com.binance.dex.api.client.crosschain.content.SideDowntimeSlash.class), + MirrorSynPack(4, 0, MirrorSyn.class), + MirrorSynAckPack(4, 1, MirrorAck.class), + MirrorSyncSynPack(5, 0, MirrorSyncSyn.class), ; private Integer channelId; diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/MirrorAck.java b/src/main/java/com/binance/dex/api/client/crosschain/content/MirrorAck.java new file mode 100644 index 0000000..e1383ab --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/MirrorAck.java @@ -0,0 +1,26 @@ +package com.binance.dex.api.client.crosschain.content; + +import com.binance.dex.api.client.crosschain.Content; +import com.binance.dex.api.client.crosschain.TokenSymbol; +import com.binance.dex.api.client.crosschain.UnsignedInt; +import com.binance.dex.api.client.crosschain.UnsignedNumber; +import com.binance.dex.api.client.encoding.message.common.EthAddressValue; +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +public class MirrorAck extends Content { + + private EthAddressValue mirrorSender; + private EthAddressValue contractAddr; + private UnsignedInt decimals; + private TokenSymbol symbol; + private UnsignedNumber mirrorFee; + private UnsignedInt errorCode; + + @Override + protected void setHrp(String hrp) { + + } +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/MirrorSyn.java b/src/main/java/com/binance/dex/api/client/crosschain/content/MirrorSyn.java new file mode 100644 index 0000000..6652885 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/MirrorSyn.java @@ -0,0 +1,25 @@ +package com.binance.dex.api.client.crosschain.content; + +import com.binance.dex.api.client.crosschain.*; +import com.binance.dex.api.client.encoding.message.common.EthAddressValue; +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +public class MirrorSyn extends Content { + + private EthAddressValue mirrorSender; + private EthAddressValue contractAddr; + private TokenSymbol name; + private TokenSymbol symbol; + private UnsignedNumber totalSupply; + private UnsignedInt decimals; + private UnsignedNumber mirrorFee; + private UnsignedLong expireTime; + + @Override + protected void setHrp(String hrp) { + + } +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/MirrorSyncAck.java b/src/main/java/com/binance/dex/api/client/crosschain/content/MirrorSyncAck.java new file mode 100644 index 0000000..77f6fbc --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/MirrorSyncAck.java @@ -0,0 +1,23 @@ +package com.binance.dex.api.client.crosschain.content; + +import com.binance.dex.api.client.crosschain.Content; +import com.binance.dex.api.client.crosschain.UnsignedInt; +import com.binance.dex.api.client.crosschain.UnsignedNumber; +import com.binance.dex.api.client.encoding.message.common.EthAddressValue; +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +public class MirrorSyncAck extends Content { + + private EthAddressValue syncSender; + private EthAddressValue contractAddr; + private UnsignedNumber syncFee; + private UnsignedInt errorCode; + + @Override + protected void setHrp(String hrp) { + + } +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/MirrorSyncSyn.java b/src/main/java/com/binance/dex/api/client/crosschain/content/MirrorSyncSyn.java new file mode 100644 index 0000000..5f52077 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/MirrorSyncSyn.java @@ -0,0 +1,26 @@ +package com.binance.dex.api.client.crosschain.content; + +import com.binance.dex.api.client.crosschain.Content; +import com.binance.dex.api.client.crosschain.TokenSymbol; +import com.binance.dex.api.client.crosschain.UnsignedLong; +import com.binance.dex.api.client.crosschain.UnsignedNumber; +import com.binance.dex.api.client.encoding.message.common.EthAddressValue; +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +public class MirrorSyncSyn extends Content { + + private EthAddressValue syncSender; + private EthAddressValue contractAddr; + private TokenSymbol symbol; + private UnsignedNumber totalSupply; + private UnsignedNumber syncFee; + private UnsignedLong expireTime; + + @Override + protected void setHrp(String hrp) { + + } +} From 9cf32796fb3de5d451096e72d04b0d580ab22bce Mon Sep 17 00:00:00 2001 From: "fletcher.fan" Date: Mon, 18 Jan 2021 17:12:52 +0800 Subject: [PATCH 26/52] add new type claim content --- .../java/com/binance/dex/api/client/crosschain/ContentEnum.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/main/java/com/binance/dex/api/client/crosschain/ContentEnum.java b/src/main/java/com/binance/dex/api/client/crosschain/ContentEnum.java index c6e5d05..9239d1c 100644 --- a/src/main/java/com/binance/dex/api/client/crosschain/ContentEnum.java +++ b/src/main/java/com/binance/dex/api/client/crosschain/ContentEnum.java @@ -22,6 +22,7 @@ public enum ContentEnum { MirrorSynPack(4, 0, MirrorSyn.class), MirrorSynAckPack(4, 1, MirrorAck.class), MirrorSyncSynPack(5, 0, MirrorSyncSyn.class), + MirrorSyncAckPack(5, 1, MirrorSyncAck.class) ; private Integer channelId; From 4a7f43dbc901a4fee3edba04b483c81b86532203 Mon Sep 17 00:00:00 2001 From: "fletcher.fan" Date: Mon, 18 Jan 2021 19:27:06 +0800 Subject: [PATCH 27/52] add change log --- CHANGELOG.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index df3a681..692aded 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,4 +1,9 @@ # Changelog + +## 1.1.1 +CHAIN UPGRADE +* [\#105](https://github.com/binance-chain/java-sdk/pull/105) [RPC] [API] support for the transfer of token ownership, and decode the new types of oracle claim package + ## 1.1.0 CHAIN UPGRADE * [\#88](https://github.com/binance-chain/java-sdk/pull/88) [RPC] [API] enable side chain governance transaction From 7f2524eab15188c80d90df302b60547a839090fd Mon Sep 17 00:00:00 2001 From: forcodedancing Date: Thu, 19 Aug 2021 17:41:36 +0800 Subject: [PATCH 28/52] migrate clients to new transaction api --- pom.xml | 2 +- .../binance/dex/api/client/BinanceDexApi.java | 7 - .../client/BinanceDexApiAsyncRestClient.java | 6 +- .../api/client/BinanceDexApiNodeClient.java | 9 +- .../api/client/BinanceDexApiRestClient.java | 6 +- .../dex/api/client/BinanceDexEnvironment.java | 29 +++ .../dex/api/client/BinanceTransactionApi.java | 22 ++ .../api/client/domain/TransactionPageV2.java | 37 ++++ .../dex/api/client/domain/TransactionV2.java | 166 +++++++++++++++ .../domain/request/TransactionsRequest.java | 88 ++++---- .../BinanceDexApiAsyncRestClientImpl.java | 42 +++- .../impl/BinanceDexApiRestClientImpl.java | 39 +++- .../api/client/utils/converter/DateUtil.java | 102 +++++++++ .../api/client/utils/converter/JsonUtil.java | 57 ++++++ .../client/utils/converter/NumberUtil.java | 42 ++++ .../dex/api/client/utils/converter/Token.java | 67 ++++++ .../utils/converter/TransactionConverter.java | 27 +++ .../TransactionConverterFactory.java | 193 ++++++++++++++++++ .../api/client/utils/converter/TxType.java | 69 +++++++ .../impl/FBscSubmitEvidenceConverter.java | 27 +++ .../utils/converter/impl/FBurnConverter.java | 22 ++ .../converter/impl/FCancelOrderConverter.java | 39 ++++ .../converter/impl/FClaimHtlConverter.java | 21 ++ .../FCreateSideChainValidatorConverter.java | 22 ++ .../impl/FCreateValidatorConverter.java | 23 +++ .../converter/impl/FCrossBindConverter.java | 33 +++ .../impl/FCrossTransferOutConverter.java | 36 ++++ .../converter/impl/FCrossUnBindConverter.java | 28 +++ .../converter/impl/FDepositConverter.java | 24 +++ .../converter/impl/FDepositHtlConverter.java | 24 +++ .../FEditSideChainValidatorConverter.java | 21 ++ .../converter/impl/FFreezeConverter.java | 22 ++ .../converter/impl/FHtlTransferConverter.java | 31 +++ .../converter/impl/FIssueTokenConverter.java | 28 +++ .../converter/impl/FListingConverter.java | 31 +++ .../impl/FMiniTokenIssueConverter.java | 29 +++ .../impl/FMiniTokenListingConverter.java | 32 +++ .../impl/FMiniTokenSetURIConverter.java | 21 ++ .../utils/converter/impl/FMintConverter.java | 24 +++ .../converter/impl/FNewOrderConverter.java | 61 ++++++ .../converter/impl/FOracleClaimConverter.java | 21 ++ .../converter/impl/FProposalConverter.java | 33 +++ .../converter/impl/FRefundHtlConverter.java | 21 ++ .../impl/FRemoveValidatorConverter.java | 21 ++ .../impl/FSetAccountFlagsConverter.java | 31 +++ .../impl/FSideChainDelegateConverter.java | 39 ++++ .../impl/FSideChainRedelegateConverter.java | 32 +++ .../impl/FSideChainUnJailConverter.java | 21 ++ .../impl/FSideChainUndelegateConverter.java | 39 ++++ .../converter/impl/FSideDepositConverter.java | 21 ++ .../impl/FSideProposalConverter.java | 32 +++ .../converter/impl/FSideVoteConverter.java | 23 +++ .../converter/impl/FTimeLockConverter.java | 30 +++ .../converter/impl/FTimeReLockConverter.java | 30 +++ .../converter/impl/FTimeUnlockConverter.java | 21 ++ .../impl/FTinyTokenIssueConverter.java | 29 +++ .../converter/impl/FTransferConverter.java | 24 +++ .../impl/FTransferOwnershipConverter.java | 31 +++ .../converter/impl/FUnfreezeConverter.java | 22 ++ .../utils/converter/impl/FVoteConverter.java | 23 +++ .../client/examples/TransactionExample.java | 40 ++++ .../examples/TransactionExampleAsync.java | 32 +++ 62 files changed, 2145 insertions(+), 80 deletions(-) create mode 100644 src/main/java/com/binance/dex/api/client/BinanceTransactionApi.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/TransactionPageV2.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/TransactionV2.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/DateUtil.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/JsonUtil.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/NumberUtil.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/Token.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/TransactionConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/TransactionConverterFactory.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/TxType.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FBscSubmitEvidenceConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FBurnConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FCancelOrderConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FClaimHtlConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FCreateSideChainValidatorConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FCreateValidatorConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FCrossBindConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FCrossTransferOutConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FCrossUnBindConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FDepositConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FDepositHtlConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FEditSideChainValidatorConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FFreezeConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FHtlTransferConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FIssueTokenConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FListingConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FMiniTokenIssueConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FMiniTokenListingConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FMiniTokenSetURIConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FMintConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FNewOrderConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FOracleClaimConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FProposalConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FRefundHtlConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FRemoveValidatorConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FSetAccountFlagsConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideChainDelegateConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideChainRedelegateConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideChainUnJailConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideChainUndelegateConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideDepositConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideProposalConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideVoteConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FTimeLockConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FTimeReLockConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FTimeUnlockConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FTinyTokenIssueConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FTransferConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FTransferOwnershipConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FUnfreezeConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FVoteConverter.java create mode 100644 src/test/java/com/binance/dex/api/client/examples/TransactionExample.java create mode 100644 src/test/java/com/binance/dex/api/client/examples/TransactionExampleAsync.java diff --git a/pom.xml b/pom.xml index 76e35d7..ac92724 100644 --- a/pom.xml +++ b/pom.xml @@ -5,7 +5,7 @@ com.binance.dex.api binance-dex-api-client - 1.1.1 + 1.1.2 2.6.0 diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexApi.java b/src/main/java/com/binance/dex/api/client/BinanceDexApi.java index 15523b9..3f54eda 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexApi.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexApi.java @@ -76,13 +76,6 @@ Call getTrades(@Query("address") String address, @Query("sellerOrderId") String sellerOrderId, @Query("side") Integer side, @Query("start") Long start, @Query("symbol") String symbol, @Query("total") Integer total); - @GET("api/v1/transactions") - Call getTransactions(@Query("address") String address, @Query("blockHeight") Long blockHeight, - @Query("endTime") Long endTime, @Query("limit") Integer limit, - @Query("offset") Integer offset, @Query("side") String side, - @Query("startTime") Long startTime, @Query("txAsset") String txAsset, - @Query("txType") String txType); - @POST("api/v1/broadcast") Call> broadcast(@Query("sync") boolean sync, @Body RequestBody transaction); diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexApiAsyncRestClient.java b/src/main/java/com/binance/dex/api/client/BinanceDexApiAsyncRestClient.java index 85061bb..4b8776d 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexApiAsyncRestClient.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexApiAsyncRestClient.java @@ -51,9 +51,11 @@ void getCandleStickBars(String symbol, CandlestickInterval interval, Integer lim void getTrades(TradesRequest request, BinanceDexApiCallback callback); - void getTransactions(String address, BinanceDexApiCallback callback); + void getTransactions(String address, BinanceDexApiCallback callback); - void getTransactions(TransactionsRequest request, BinanceDexApiCallback callback); + void getTransactions(TransactionsRequest request, BinanceDexApiCallback callback); + + void getTransactionsInBlock(long blockHeight, BinanceDexApiCallback callback); // Do not support async commitBroadcast due to account sequence } diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java b/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java index 4829ee0..849484b 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java @@ -132,12 +132,17 @@ default TradePage getTrades(TradesRequest request) { } @Override - default TransactionPage getTransactions(String address) { + default TransactionPageV2 getTransactions(String address) { throw new UnsupportedOperationException(); } @Override - default TransactionPage getTransactions(TransactionsRequest request) { + default TransactionPageV2 getTransactions(TransactionsRequest request) { + throw new UnsupportedOperationException(); + } + + @Override + default TransactionPageV2 getTransactionsInBlock(long blockHeight) { throw new UnsupportedOperationException(); } diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexApiRestClient.java b/src/main/java/com/binance/dex/api/client/BinanceDexApiRestClient.java index 7fafa8f..005309f 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexApiRestClient.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexApiRestClient.java @@ -56,9 +56,11 @@ public interface BinanceDexApiRestClient { TradePage getTrades(TradesRequest request); - TransactionPage getTransactions(String address); + TransactionPageV2 getTransactions(String address); - TransactionPage getTransactions(TransactionsRequest request); + TransactionPageV2 getTransactions(TransactionsRequest request); + + TransactionPageV2 getTransactionsInBlock(long blockHeight); List getMiniTokens(Integer limit); diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexEnvironment.java b/src/main/java/com/binance/dex/api/client/BinanceDexEnvironment.java index 3fb1e96..f049130 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexEnvironment.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexEnvironment.java @@ -6,6 +6,7 @@ public class BinanceDexEnvironment { public static final BinanceDexEnvironment PROD = new BinanceDexEnvironment( "https://dex.binance.org", + "https://api.binance.org/bc/", "wss://dex.binance.org/api", "https://dataseed1.ninicoin.io", "wss://dataseed1.ninicoin.io/websocket", @@ -14,6 +15,7 @@ public class BinanceDexEnvironment { ); public static final BinanceDexEnvironment TEST_NET = new BinanceDexEnvironment( "https://testnet-dex.binance.org", + "https://testnet-api.binance.org/bc/", "wss://testnet-dex.binance.org/api", "http://data-seed-pre-0-s3.binance.org", "wss://data-seed-pre-0-s3.binance.org/websocket", @@ -23,6 +25,8 @@ public class BinanceDexEnvironment { // Rest API base URL private String baseUrl; + // Chain transaction API base URL + private String transactionUrl; // Websocket data stream url private String streamUrl; // RPC API base URL @@ -41,12 +45,27 @@ public BinanceDexEnvironment(String baseUrl, String streamUrl, String nodeUrl, S this.wsBaseUrl = wsBaseUrl; this.hrp = hrp; this.valHrp = valHrp; + this.transactionUrl = inferTransactionUrl(baseUrl); + } + + public BinanceDexEnvironment(String baseUrl, String transactionUrl, String streamUrl, String nodeUrl, String wsBaseUrl, String hrp, String valHrp) { + this.baseUrl = baseUrl; + this.transactionUrl = transactionUrl; + this.streamUrl = streamUrl; + this.nodeUrl = nodeUrl; + this.wsBaseUrl = wsBaseUrl; + this.hrp = hrp; + this.valHrp = valHrp; } public String getBaseUrl() { return baseUrl; } + public String getTransactionUrl() { + return transactionUrl; + } + public String getStreamUrl() { return streamUrl; } @@ -63,6 +82,16 @@ public String getValHrp() { return valHrp; } + public static String inferTransactionUrl(String baseUrl) { + String transactionUrl = null; + if (baseUrl != null && baseUrl.equalsIgnoreCase(BinanceDexEnvironment.PROD.baseUrl)) { + transactionUrl = BinanceDexEnvironment.PROD.transactionUrl; + } else if (baseUrl != null && baseUrl.equalsIgnoreCase(BinanceDexEnvironment.TEST_NET.baseUrl)) { + transactionUrl = BinanceDexEnvironment.TEST_NET.transactionUrl; + } + return transactionUrl; + } + @Override public boolean equals(Object o) { if (this == o) return true; diff --git a/src/main/java/com/binance/dex/api/client/BinanceTransactionApi.java b/src/main/java/com/binance/dex/api/client/BinanceTransactionApi.java new file mode 100644 index 0000000..314d894 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/BinanceTransactionApi.java @@ -0,0 +1,22 @@ +package com.binance.dex.api.client; + +import com.binance.dex.api.client.domain.TransactionPageV2; +import retrofit2.Call; +import retrofit2.http.GET; +import retrofit2.http.Path; +import retrofit2.http.Query; + +public interface BinanceTransactionApi { + @GET("api/v1/txs") + Call getTransactions(@Query(value = "startTime") Long startTime, + @Query(value = "endTime") Long endTime, + @Query(value = "type") String type, + @Query(value = "asset") String asset, + @Query(value = "address") String address, + @Query(value = "addressType") String addressType, + @Query(value = "offset") Integer offset, + @Query(value = "limit") Integer limit); + + @GET("api/v1/blocks/{blockHeight}/txs") + Call getTransactionsInBlock(@Path("blockHeight") long blockHeight); +} diff --git a/src/main/java/com/binance/dex/api/client/domain/TransactionPageV2.java b/src/main/java/com/binance/dex/api/client/domain/TransactionPageV2.java new file mode 100644 index 0000000..07640d1 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/TransactionPageV2.java @@ -0,0 +1,37 @@ +package com.binance.dex.api.client.domain; + +import com.binance.dex.api.client.BinanceDexConstants; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import org.apache.commons.lang3.builder.ToStringBuilder; + +import java.util.List; + +@JsonIgnoreProperties(ignoreUnknown = true) +public class TransactionPageV2 { + private Long total; + private List txs; + + public Long getTotal() { + return total; + } + + public void setTotal(Long total) { + this.total = total; + } + + public List getTxs() { + return txs; + } + + public void setTxs(List txs) { + this.txs = txs; + } + + @Override + public String toString() { + return new ToStringBuilder(this, BinanceDexConstants.BINANCE_DEX_TO_STRING_STYLE) + .append("total", total) + .append("txs", txs) + .toString(); + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/TransactionV2.java b/src/main/java/com/binance/dex/api/client/domain/TransactionV2.java new file mode 100644 index 0000000..f47c764 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/TransactionV2.java @@ -0,0 +1,166 @@ +package com.binance.dex.api.client.domain; + +import com.binance.dex.api.client.BinanceDexConstants; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import org.apache.commons.lang3.builder.ToStringBuilder; + +@JsonIgnoreProperties(ignoreUnknown = true) +public class TransactionV2 { + private String hash; + private long blockHeight; + private long blockTime; + private String type; + private Long fee; + private int code; + private long source; + private long sequence; + private String memo; + private String log; + private String data; + + private String asset; + private Long amount; + + private String fromAddr; + private String toAddr; + + public String getHash() { + return hash; + } + + public void setHash(String hash) { + this.hash = hash; + } + + public long getBlockHeight() { + return blockHeight; + } + + public void setBlockHeight(long blockHeight) { + this.blockHeight = blockHeight; + } + + public long getBlockTime() { + return blockTime; + } + + public void setBlockTime(long blockTime) { + this.blockTime = blockTime; + } + + public String getType() { + return type; + } + + public void setType(String type) { + this.type = type; + } + + public Long getFee() { + return fee; + } + + public void setFee(Long fee) { + this.fee = fee; + } + + public int getCode() { + return code; + } + + public void setCode(int code) { + this.code = code; + } + + public long getSource() { + return source; + } + + public void setSource(long source) { + this.source = source; + } + + public long getSequence() { + return sequence; + } + + public void setSequence(long sequence) { + this.sequence = sequence; + } + + public String getMemo() { + return memo; + } + + public void setMemo(String memo) { + this.memo = memo; + } + + public String getLog() { + return log; + } + + public void setLog(String log) { + this.log = log; + } + + public String getData() { + return data; + } + + public void setData(String data) { + this.data = data; + } + + public String getAsset() { + return asset; + } + + public void setAsset(String asset) { + this.asset = asset; + } + + public Long getAmount() { + return amount; + } + + public void setAmount(Long amount) { + this.amount = amount; + } + + public String getFromAddr() { + return fromAddr; + } + + public void setFromAddr(String fromAddr) { + this.fromAddr = fromAddr; + } + + public String getToAddr() { + return toAddr; + } + + public void setToAddr(String toAddr) { + this.toAddr = toAddr; + } + + @Override + public String toString() { + return new ToStringBuilder(this, BinanceDexConstants.BINANCE_DEX_TO_STRING_STYLE) + .append("blockHeight", blockHeight) + .append("code", code) + .append("data", data) + .append("fromAddr", fromAddr) + .append("blockTime", blockTime) + .append("toAddr", toAddr) + .append("asset", asset) + .append("fee", fee) + .append("hash", hash) + .append("type", type) + .append("amount", amount) + .append("memo", memo) + .append("sequence", sequence) + .append("log", log) + .toString(); + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/request/TransactionsRequest.java b/src/main/java/com/binance/dex/api/client/domain/request/TransactionsRequest.java index d203c28..6f0630e 100644 --- a/src/main/java/com/binance/dex/api/client/domain/request/TransactionsRequest.java +++ b/src/main/java/com/binance/dex/api/client/domain/request/TransactionsRequest.java @@ -6,30 +6,21 @@ import org.apache.commons.lang3.builder.ToStringBuilder; public class TransactionsRequest { - private String address; - private Long blockHeight; + private Long startTime; private Long endTime; - private Integer limit; + private String type; + private String asset; + private String address; + private String addressType; private Integer offset; - private OrderSide side; - private Long startTime; - private String txAsset; - private TransactionType txType; - - public String getAddress() { - return address; - } - - public void setAddress(String address) { - this.address = address; - } + private Integer limit; - public Long getBlockHeight() { - return blockHeight; + public Long getStartTime() { + return startTime; } - public void setBlockHeight(Long blockHeight) { - this.blockHeight = blockHeight; + public void setStartTime(Long startTime) { + this.startTime = startTime; } public Long getEndTime() { @@ -40,66 +31,65 @@ public void setEndTime(Long endTime) { this.endTime = endTime; } - public Integer getLimit() { - return limit; + public String getType() { + return type; } - public void setLimit(Integer limit) { - this.limit = limit; + public void setType(String type) { + this.type = type; } - public Integer getOffset() { - return offset; + public String getAsset() { + return asset; } - public void setOffset(Integer offset) { - this.offset = offset; + public void setAsset(String asset) { + this.asset = asset; } - public OrderSide getSide() { - return side; + public String getAddress() { + return address; } - public void setSide(OrderSide side) { - this.side = side; + public void setAddress(String address) { + this.address = address; } - public Long getStartTime() { - return startTime; + public String getAddressType() { + return addressType; } - public void setStartTime(Long startTime) { - this.startTime = startTime; + public void setAddressType(String addressType) { + this.addressType = addressType; } - public String getTxAsset() { - return txAsset; + public Integer getOffset() { + return offset; } - public void setTxAsset(String txAsset) { - this.txAsset = txAsset; + public void setOffset(Integer offset) { + this.offset = offset; } - public TransactionType getTxType() { - return txType; + public Integer getLimit() { + return limit; } - public void setTxType(TransactionType txType) { - this.txType = txType; + public void setLimit(Integer limit) { + this.limit = limit; } @Override public String toString() { return new ToStringBuilder(this, BinanceDexConstants.BINANCE_DEX_TO_STRING_STYLE) - .append("address", address) - .append("blockHeight", blockHeight) + .append("startTime", startTime) .append("endTime", endTime) + .append("type", type) + .append("asset", asset) + .append("address", address) + .append("addressType", addressType) .append("limit", limit) .append("offset", offset) - .append("side", side) - .append("startTime", startTime) - .append("txAsset", txAsset) - .append("txType", txType) .toString(); } } diff --git a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiAsyncRestClientImpl.java b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiAsyncRestClientImpl.java index 967f5e7..756e694 100644 --- a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiAsyncRestClientImpl.java +++ b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiAsyncRestClientImpl.java @@ -8,21 +8,35 @@ import com.binance.dex.api.client.domain.request.TransactionsRequest; import org.apache.commons.lang3.StringUtils; +import java.util.Date; import java.util.List; import java.util.stream.Collectors; public class BinanceDexApiAsyncRestClientImpl implements BinanceDexApiAsyncRestClient { private BinanceDexApi binanceDexApi; + private BinanceTransactionApi binanceTransactionApi; public BinanceDexApiAsyncRestClientImpl(String baseUrl) { this.binanceDexApi = BinanceDexApiClientGenerator.createService(BinanceDexApi.class, baseUrl); + + String transactionUrl = BinanceDexEnvironment.inferTransactionUrl(baseUrl); + if (transactionUrl != null) { + this.binanceTransactionApi = BinanceDexApiClientGenerator.createService(BinanceTransactionApi.class, transactionUrl); + } } - public BinanceDexApiAsyncRestClientImpl(String baseUrl,String apiKey){ + public BinanceDexApiAsyncRestClientImpl(String baseUrl, String apiKey){ + String transactionUrl = BinanceDexEnvironment.inferTransactionUrl(baseUrl); if(StringUtils.isBlank(apiKey)){ this.binanceDexApi = BinanceDexApiClientGenerator.createService(BinanceDexApi.class, baseUrl); + if (transactionUrl != null) { + this.binanceTransactionApi = BinanceDexApiClientGenerator.createService(BinanceTransactionApi.class, transactionUrl); + } }else{ this.binanceDexApi = BinanceDexApiClientGenerator.createService(BinanceDexApi.class,apiKey,baseUrl + "/internal/"); + if (transactionUrl != null) { + this.binanceTransactionApi = BinanceDexApiClientGenerator.createService(BinanceTransactionApi.class, transactionUrl + "/internal/"); + } } } @@ -149,20 +163,30 @@ public void getTrades(TradesRequest request, BinanceDexApiCallback ca } @Override - public void getTransactions(String address, BinanceDexApiCallback callback) { + public void getTransactions(String address, BinanceDexApiCallback callback) { TransactionsRequest request = new TransactionsRequest(); request.setAddress(address); + Long endTime = new Date().getTime(); + Long startTime = endTime - 86400000; + request.setStartTime(startTime); + request.setEndTime(endTime); getTransactions(request, callback); } @Override - public void getTransactions(TransactionsRequest request, BinanceDexApiCallback callback) { - String sideStr = request.getSide() == null ? null : request.getSide().name(); - String txTypeStr = request.getTxType() != null ? request.getTxType().name() : null; - binanceDexApi.getTransactions( - request.getAddress(), request.getBlockHeight(), request.getEndTime(), - request.getLimit(), request.getOffset(), sideStr, - request.getStartTime(), request.getTxAsset(), txTypeStr).enqueue( + public void getTransactions(TransactionsRequest request, BinanceDexApiCallback callback) { + binanceTransactionApi.getTransactions( + request.getStartTime(), request.getEndTime(), + request.getType(), request.getAsset(), + request.getAddress(), request.getAddressType(), + request.getOffset(), request.getLimit()).enqueue( + new BinanceDexApiCallbackAdapter<>(callback)); + } + + @Override + public void getTransactionsInBlock(long blockHeight, BinanceDexApiCallback callback) { + binanceTransactionApi.getTransactionsInBlock( + blockHeight).enqueue( new BinanceDexApiCallbackAdapter<>(callback)); } } diff --git a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiRestClientImpl.java b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiRestClientImpl.java index b090354..21a69b4 100644 --- a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiRestClientImpl.java +++ b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiRestClientImpl.java @@ -13,6 +13,7 @@ import java.io.IOException; import java.security.NoSuchAlgorithmException; +import java.util.Date; import java.util.List; import java.util.stream.Collectors; @@ -22,17 +23,29 @@ */ public class BinanceDexApiRestClientImpl implements BinanceDexApiRestClient { private BinanceDexApi binanceDexApi; + private BinanceTransactionApi binanceTransactionApi; private static final okhttp3.MediaType MEDIA_TYPE = okhttp3.MediaType.parse("text/plain; charset=utf-8"); public BinanceDexApiRestClientImpl(String baseUrl) { this.binanceDexApi = BinanceDexApiClientGenerator.createService(BinanceDexApi.class, baseUrl); + String transactionUrl = BinanceDexEnvironment.inferTransactionUrl(baseUrl); + if (transactionUrl != null) { + this.binanceTransactionApi = BinanceDexApiClientGenerator.createService(BinanceTransactionApi.class, transactionUrl); + } } public BinanceDexApiRestClientImpl(String baseUrl,String apiKey){ + String transactionUrl = BinanceDexEnvironment.inferTransactionUrl(baseUrl); if(StringUtils.isBlank(apiKey)){ this.binanceDexApi = BinanceDexApiClientGenerator.createService(BinanceDexApi.class, baseUrl); + if (transactionUrl != null) { + this.binanceTransactionApi = BinanceDexApiClientGenerator.createService(BinanceTransactionApi.class, transactionUrl); + } }else{ this.binanceDexApi = BinanceDexApiClientGenerator.createService(BinanceDexApi.class,apiKey,baseUrl + "/internal/"); + if (transactionUrl != null) { + this.binanceTransactionApi = BinanceDexApiClientGenerator.createService(BinanceTransactionApi.class, transactionUrl + "/internal/"); + } } } @@ -147,21 +160,31 @@ public TradePage getTrades(TradesRequest request) { } @Override - public TransactionPage getTransactions(String address) { + public TransactionPageV2 getTransactions(String address) { TransactionsRequest request = new TransactionsRequest(); request.setAddress(address); + Long endTime = new Date().getTime(); + Long startTime = endTime - 86400000; + request.setStartTime(startTime); + request.setEndTime(endTime); return getTransactions(request); } @Override - public TransactionPage getTransactions(TransactionsRequest request) { - String sideStr = request.getSide() != null ? request.getSide().name() : null; - String txTypeStr = request.getTxType() != null ? request.getTxType().name() : null; + public TransactionPageV2 getTransactions(TransactionsRequest request) { + return BinanceDexApiClientGenerator.executeSync( + binanceTransactionApi.getTransactions( + request.getStartTime(), request.getEndTime(), + request.getType(), request.getAsset(), + request.getAddress(), request.getAddressType(), + request.getOffset(), request.getLimit())); + } + + + @Override + public TransactionPageV2 getTransactionsInBlock(long blockHeight) { return BinanceDexApiClientGenerator.executeSync( - binanceDexApi.getTransactions( - request.getAddress(), request.getBlockHeight(), request.getEndTime(), - request.getLimit(), request.getOffset(), sideStr, - request.getStartTime(), request.getTxAsset(), txTypeStr)); + binanceTransactionApi.getTransactionsInBlock(blockHeight)); } // Broadcast and handle account sequence diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/DateUtil.java b/src/main/java/com/binance/dex/api/client/utils/converter/DateUtil.java new file mode 100644 index 0000000..781cfe7 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/DateUtil.java @@ -0,0 +1,102 @@ +package com.binance.dex.api.client.utils.converter; + +import java.text.SimpleDateFormat; +import java.time.*; +import java.time.format.DateTimeFormatter; +import java.time.temporal.ChronoUnit; +import java.util.Calendar; +import java.util.Date; +import java.util.TimeZone; + +public class DateUtil { + + private static final DateTimeFormatter utcFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").withZone(ZoneId.of("UTC")); + + public static long betweenSecs(Date date1, Date date2) { + return Duration.between(date1.toInstant(), date2.toInstant()).getSeconds(); + } + + public static long betweenDays(Date date1, Date date2) { + return date1.toInstant().until(date2.toInstant(), ChronoUnit.DAYS); + } + + public static boolean isSameDay(Date date1, Date date2) { + Calendar cal1 = Calendar.getInstance(); + Calendar cal2 = Calendar.getInstance(); + cal1.setTime(date1); + cal2.setTime(date2); + return cal1.get(Calendar.DAY_OF_YEAR) == cal2.get(Calendar.DAY_OF_YEAR) && + cal1.get(Calendar.YEAR) == cal2.get(Calendar.YEAR); + } + + public static Date toDateFromMilliseconds(Long time) { + if (null == time) { + return null; + } + return Date.from(Instant.ofEpochMilli(time)); + } + + public static Date now() { + return Date.from(Instant.now()); + } + + public static Date parseUTCMilliTime(String dateStr) { + ZonedDateTime zdt = ZonedDateTime.parse(dateStr, utcFormatter); + return Date.from(zdt.toInstant()); + } + + public static Date parseUTCTime(String dateStr) { + return Date.from(Instant.parse(dateStr)); + } + + /** + * Formats a date at any given format String, at any given Timezone String. + * + * @param date Valid Date object + * @param format String representation of the format, e.g. "yyyy-MM-dd HH:mm" + * @param timezone String representation of the time zone, e.g. "CST" + * @return The formatted date in the given time zone. + */ + public static String toString(final Date date, final String format, final String timezone) { + final TimeZone tz = TimeZone.getTimeZone(timezone); + final SimpleDateFormat formatter = new SimpleDateFormat(format); + formatter.setTimeZone(tz); + return formatter.format(date); + } + + private static LocalDateTime dateToUtcDateTime(Date date) { + return LocalDateTime.ofInstant(date.toInstant(), ZoneId.of("UTC")); + } + + private static Date utcDateTimeToDate(LocalDateTime localDateTime) { + return Date.from(localDateTime.atZone(ZoneId.of("UTC")).toInstant()); + } + + public static Date getPreviousDate(Date date) { + LocalDateTime localDateTime = dateToUtcDateTime(date); + LocalDateTime previousDate = localDateTime.minusDays(1l); + return utcDateTimeToDate(previousDate); + } + + public static String toUTCDateString(final Date date) { + return toString(date, "yyyyMMdd", "UTC"); + } + + public static String toUTCDateString(long timeStamp) { + return toString(new Date(timeStamp), "yyyyMMdd", "UTC"); + } + + public static Date atStartOfDay(Date date) { + LocalDateTime localDateTime = dateToUtcDateTime(date); + LocalDateTime startOfDay = localDateTime.with(LocalTime.MIN); + return utcDateTimeToDate(startOfDay); + } + + public static Date atEndOfDay(Date date) { + LocalDateTime localDateTime = dateToUtcDateTime(date); + LocalDateTime endOfDay = localDateTime.with(LocalTime.MAX); + return utcDateTimeToDate(endOfDay); + } + + +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/JsonUtil.java b/src/main/java/com/binance/dex/api/client/utils/converter/JsonUtil.java new file mode 100644 index 0000000..9b9e399 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/JsonUtil.java @@ -0,0 +1,57 @@ +package com.binance.dex.api.client.utils.converter; + +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.node.ObjectNode; +import com.fasterxml.jackson.databind.type.TypeFactory; + +import java.io.IOException; +import java.util.List; + +public class JsonUtil { + + private static final ObjectMapper objectMapper = new ObjectMapper(); + private static final TypeFactory typeFactory = objectMapper.getTypeFactory(); + + static { + objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + } + + + public static ObjectNode createObjectNode() { + return objectMapper.createObjectNode(); + } + + public static String toJson(Object value) { + try { + return objectMapper.writeValueAsString(value); + } catch (JsonProcessingException e) { + throw new RuntimeException(e); + } + } + + public static T fromJson(String jsonStr, Class tClass) { + try { + return objectMapper.readValue(jsonStr, tClass); + } catch (IOException e) { + e.printStackTrace(); + throw new RuntimeException(e); + } + } + + public static List fromJsonToList(String jsonStr, Class tClass) { + try { + return objectMapper.readValue(jsonStr, typeFactory.constructCollectionType(List.class, tClass)); + } catch (IOException e) { + throw new RuntimeException(e); + } + + } + + public static JsonNode toJsonNode(String json) throws Exception { + return objectMapper.readTree(json); + } + +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/NumberUtil.java b/src/main/java/com/binance/dex/api/client/utils/converter/NumberUtil.java new file mode 100644 index 0000000..7d7133a --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/NumberUtil.java @@ -0,0 +1,42 @@ +package com.binance.dex.api.client.utils.converter; + +import java.math.BigDecimal; +import java.text.DecimalFormat; + +public class NumberUtil { + + public static final Integer SHIFT_DIGITS = 8; + + public static BigDecimal longToBigDecimal(Long value) { + return longToBigDecimal(value, SHIFT_DIGITS); + } + + public static String longToBigDecimalString(Long value) { + return decimalFormat(longToBigDecimal(value, SHIFT_DIGITS)); + } + + public static BigDecimal longToBigDecimal(Long value, Integer shiftDigits) { + if (null == value) { + return null; + } + return BigDecimal.valueOf(value).movePointLeft(shiftDigits); + } + + public static Long bigDecimalToLong(BigDecimal value) { + return bigDecimalToLong(value, SHIFT_DIGITS); + } + + private static Long bigDecimalToLong(BigDecimal value, Integer precision) { + if (null == value) { + return null; + } + return value.multiply(BigDecimal.TEN.pow(precision)).longValue(); + } + + public static String decimalFormat(BigDecimal value) { + if (value == null) { + return null; + } + return new DecimalFormat("0.00000000").format(value); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/Token.java b/src/main/java/com/binance/dex/api/client/utils/converter/Token.java new file mode 100644 index 0000000..144f0f3 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/Token.java @@ -0,0 +1,67 @@ +package com.binance.dex.api.client.utils.converter; + +import com.binance.dex.api.client.BinanceDexConstants; +import com.binance.dex.api.proto.Send; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import lombok.Builder; +import lombok.Data; +import org.apache.commons.lang3.builder.ToStringBuilder; + +@Data +@Builder +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class Token { + @JsonProperty(value = "denom") + private String denom; + @JsonProperty(value = "amount") + private Long amount; + + public static com.binance.dex.api.client.encoding.message.Token of(com.binance.dex.api.proto.Token source) { + com.binance.dex.api.client.encoding.message.Token token = new com.binance.dex.api.client.encoding.message.Token(); + token.setDenom(source.getDenom()); + token.setAmount(source.getAmount()); + return token; + } + + public static com.binance.dex.api.client.encoding.message.Token of(Send.Token sendToken) { + com.binance.dex.api.client.encoding.message.Token token = new com.binance.dex.api.client.encoding.message.Token(); + token.setDenom(sendToken.getDenom()); + token.setAmount(sendToken.getAmount()); + return token; + } + + public Token() { + } + + public Token(String denom, Long amount) { + this.denom = denom; + this.amount = amount; + } + + public String getDenom() { + return denom; + } + + public void setDenom(String denom) { + this.denom = denom; + } + + public Long getAmount() { + return amount; + } + + public void setAmount(Long amount) { + this.amount = amount; + } + + @Override + public String toString() { + return new ToStringBuilder(this, BinanceDexConstants.BINANCE_DEX_TO_STRING_STYLE) + .append("denom", denom) + .append("amount", amount) + .toString(); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/TransactionConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/TransactionConverter.java new file mode 100644 index 0000000..37aa3a3 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/TransactionConverter.java @@ -0,0 +1,27 @@ +package com.binance.dex.api.client.utils.converter; + + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; + +import java.util.Map; + + +public abstract class TransactionConverter { + + // construct tx data information based on different tx types + public abstract void doConvert(TransactionV2 transactionV2, Transaction transaction); + + public abstract com.binance.dex.api.client.domain.broadcast.TxType getType(); + + protected Token getToken(Map map, String key) { + Map m = (Map) map.get(key); + String denom = m.get("denom").toString(); + Long amount = ((Number) m.get("amount")).longValue(); + Token token = new Token(); + token.setDenom(denom); + token.setAmount(amount); + return token; + } + +} \ No newline at end of file diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/TransactionConverterFactory.java b/src/main/java/com/binance/dex/api/client/utils/converter/TransactionConverterFactory.java new file mode 100644 index 0000000..e4a0491 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/TransactionConverterFactory.java @@ -0,0 +1,193 @@ +package com.binance.dex.api.client.utils.converter; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionPage; +import com.binance.dex.api.client.domain.TransactionPageV2; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.utils.converter.impl.*; +import com.google.common.collect.Maps; + +import java.text.SimpleDateFormat; +import java.util.ArrayList; +import java.util.Date; +import java.util.Map; + + +public class TransactionConverterFactory { + + private static Map converterMap = Maps.newHashMap(); + + static { + FBscSubmitEvidenceConverter bscSubmitEvidenceConverter = new FBscSubmitEvidenceConverter(); + converterMap.put(bscSubmitEvidenceConverter.getType(), bscSubmitEvidenceConverter); + + FBurnConverter burnConverter = new FBurnConverter(); + converterMap.put(burnConverter.getType(), burnConverter); + + FCancelOrderConverter cancelOrderConverter = new FCancelOrderConverter(); + converterMap.put(cancelOrderConverter.getType(), cancelOrderConverter); + + FClaimHtlConverter claimHtlConverter = new FClaimHtlConverter(); + converterMap.put(claimHtlConverter.getType(), claimHtlConverter); + + FCreateSideChainValidatorConverter createSideChainValidatorConverter = new FCreateSideChainValidatorConverter(); + converterMap.put(createSideChainValidatorConverter.getType(), createSideChainValidatorConverter); + + FCreateValidatorConverter createValidatorConverter = new FCreateValidatorConverter(); + converterMap.put(createValidatorConverter.getType(), createValidatorConverter); + + FCrossBindConverter crossBindConverter = new FCrossBindConverter(); + converterMap.put(crossBindConverter.getType(), crossBindConverter); + + FCrossTransferOutConverter crossTransferOutConverter = new FCrossTransferOutConverter(); + converterMap.put(crossTransferOutConverter.getType(), crossTransferOutConverter); + + FCrossUnBindConverter crossUnBindConverter = new FCrossUnBindConverter(); + converterMap.put(crossUnBindConverter.getType(), crossUnBindConverter); + + FDepositConverter depositConverter = new FDepositConverter(); + converterMap.put(depositConverter.getType(), depositConverter); + + FDepositHtlConverter depositHtlConverter = new FDepositHtlConverter(); + converterMap.put(depositHtlConverter.getType(), depositHtlConverter); + + FEditSideChainValidatorConverter editSideChainValidatorConverter = new FEditSideChainValidatorConverter(); + converterMap.put(editSideChainValidatorConverter.getType(), editSideChainValidatorConverter); + + FFreezeConverter freezeConverter = new FFreezeConverter(); + converterMap.put(freezeConverter.getType(), freezeConverter); + + FHtlTransferConverter htlTransferConverter = new FHtlTransferConverter(); + converterMap.put(htlTransferConverter.getType(), htlTransferConverter); + + FIssueTokenConverter issueTokenConverter = new FIssueTokenConverter(); + converterMap.put(issueTokenConverter.getType(), issueTokenConverter); + + FListingConverter listingConverter = new FListingConverter(); + converterMap.put(listingConverter.getType(), listingConverter); + + FMiniTokenIssueConverter miniTokenIssueConverter = new FMiniTokenIssueConverter(); + converterMap.put(miniTokenIssueConverter.getType(), miniTokenIssueConverter); + + FMiniTokenListingConverter miniTokenListingConverter = new FMiniTokenListingConverter(); + converterMap.put(miniTokenListingConverter.getType(), miniTokenListingConverter); + + FMiniTokenSetURIConverter miniTokenSetURIConverter = new FMiniTokenSetURIConverter(); + converterMap.put(miniTokenSetURIConverter.getType(), miniTokenSetURIConverter); + + FMintConverter mintConverter = new FMintConverter(); + converterMap.put(mintConverter.getType(), mintConverter); + + FNewOrderConverter newOrderConverter = new FNewOrderConverter(); + converterMap.put(newOrderConverter.getType(), newOrderConverter); + + FOracleClaimConverter oracleClaimConverter = new FOracleClaimConverter(); + converterMap.put(oracleClaimConverter.getType(), oracleClaimConverter); + + FProposalConverter proposalConverter = new FProposalConverter(); + converterMap.put(proposalConverter.getType(), proposalConverter); + + FRefundHtlConverter refundHtlConverter = new FRefundHtlConverter(); + converterMap.put(refundHtlConverter.getType(), refundHtlConverter); + + FRemoveValidatorConverter removeValidatorConverter = new FRemoveValidatorConverter(); + converterMap.put(removeValidatorConverter.getType(), removeValidatorConverter); + + FSetAccountFlagsConverter setAccountFlagsConverter = new FSetAccountFlagsConverter(); + converterMap.put(setAccountFlagsConverter.getType(), setAccountFlagsConverter); + + FSideChainDelegateConverter sideChainDelegateConverter = new FSideChainDelegateConverter(); + converterMap.put(sideChainDelegateConverter.getType(), sideChainDelegateConverter); + + FSideChainRedelegateConverter sideChainRedelegateConverter = new FSideChainRedelegateConverter(); + converterMap.put(sideChainRedelegateConverter.getType(), sideChainRedelegateConverter); + + FSideChainUnJailConverter sideChainUnJailConverter = new FSideChainUnJailConverter(); + converterMap.put(sideChainUnJailConverter.getType(), sideChainUnJailConverter); + + FSideChainUndelegateConverter sideChainUndelegateConverter = new FSideChainUndelegateConverter(); + converterMap.put(sideChainUndelegateConverter.getType(), sideChainUndelegateConverter); + + FSideDepositConverter sideDepositConverter = new FSideDepositConverter(); + converterMap.put(sideDepositConverter.getType(), sideDepositConverter); + + FSideProposalConverter sideProposalConverter = new FSideProposalConverter(); + converterMap.put(sideProposalConverter.getType(), sideProposalConverter); + + FSideVoteConverter sideVoteConverter = new FSideVoteConverter(); + converterMap.put(sideVoteConverter.getType(), sideVoteConverter); + + FTimeLockConverter timeLockConverter = new FTimeLockConverter(); + converterMap.put(timeLockConverter.getType(), timeLockConverter); + + FTimeReLockConverter timeReLockConverter = new FTimeReLockConverter(); + converterMap.put(timeReLockConverter.getType(), timeReLockConverter); + + FTimeUnlockConverter timeUnlockConverter = new FTimeUnlockConverter(); + converterMap.put(timeUnlockConverter.getType(), timeUnlockConverter); + + FTinyTokenIssueConverter tinyTokenIssueConverter = new FTinyTokenIssueConverter(); + converterMap.put(tinyTokenIssueConverter.getType(), tinyTokenIssueConverter); + + FTransferConverter transferConverter = new FTransferConverter(); + converterMap.put(transferConverter.getType(), transferConverter); + + FTransferOwnershipConverter transferOwnershipConverter = new FTransferOwnershipConverter(); + converterMap.put(transferOwnershipConverter.getType(), transferOwnershipConverter); + + FUnfreezeConverter unfreezeConverter = new FUnfreezeConverter(); + converterMap.put(unfreezeConverter.getType(), unfreezeConverter); + + FVoteConverter voteConverter = new FVoteConverter(); + converterMap.put(voteConverter.getType(), voteConverter); + } + + public static T getConverter(com.binance.dex.api.client.domain.broadcast.TxType txType) { + if (converterMap.containsKey(txType)) { + return (T) converterMap.get(txType); + } + return null; + } + + + public Transaction convert(TransactionV2 transactionV2) { + SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"); + if (transactionV2 == null) { + return null; + } + Transaction transaction = new Transaction(); + transaction.setBlockHeight(transactionV2.getBlockHeight()); + transaction.setTxHash(transactionV2.getHash()); + transaction.setTxType(transactionV2.getType()); + transaction.setTimeStamp(formatter.format(new Date(transactionV2.getBlockTime()))); + + + transaction.setCode(transactionV2.getCode()); + transaction.setMemo(transactionV2.getMemo()); + + transaction.setTxAsset(transactionV2.getAsset()); + transaction.setFromAddr(transactionV2.getFromAddr()); + transaction.setData(transactionV2.getData()); + + transaction.setTxAge(DateUtil.betweenSecs(new Date(transactionV2.getBlockTime()), DateUtil.now())); + + transaction.setTxFee(NumberUtil.longToBigDecimalString(transactionV2.getFee())); + + TransactionConverter converter = getConverter(TxType.getTypeByName(transactionV2.getType())); + converter.doConvert(transactionV2, transaction); + + return transaction; + } + + public TransactionPage convert(TransactionPageV2 transactionPageV2) { + TransactionPage transactionPage = new TransactionPage(); + if (transactionPageV2 != null) { + transactionPage.setTotal(transactionPageV2.getTotal()); + transactionPage.setTx(new ArrayList<>()); + transactionPageV2.getTxs().stream().forEach(tx -> { + transactionPage.getTx().add(convert(tx)); + }); + } + return transactionPage; + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/TxType.java b/src/main/java/com/binance/dex/api/client/utils/converter/TxType.java new file mode 100644 index 0000000..5e4fddb --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/TxType.java @@ -0,0 +1,69 @@ +package com.binance.dex.api.client.utils.converter; + +import java.util.HashMap; +import java.util.Map; + +public enum TxType { + NEW_ORDER(com.binance.dex.api.client.domain.broadcast.TxType.NEW_ORDER), + ISSUE_TOKEN(com.binance.dex.api.client.domain.broadcast.TxType.ISSUE), + BURN_TOKEN(com.binance.dex.api.client.domain.broadcast.TxType.BURN), + LIST_TOKEN(com.binance.dex.api.client.domain.broadcast.TxType.LISTING), + CANCEL_ORDER(com.binance.dex.api.client.domain.broadcast.TxType.CANCEL_ORDER), + FREEZE_TOKEN(com.binance.dex.api.client.domain.broadcast.TxType.FREEZE_TOKEN), + UN_FREEZE_TOKEN(com.binance.dex.api.client.domain.broadcast.TxType.UNFREEZE_TOKEN), + TRANSFER(com.binance.dex.api.client.domain.broadcast.TxType.TRANSFER), + PROPOSAL(com.binance.dex.api.client.domain.broadcast.TxType.SUBMIT_PROPOSAL), + SIDE_PROPOSAL(com.binance.dex.api.client.domain.broadcast.TxType.SIDE_SUBMIT_PROPOSAL), + VOTE(com.binance.dex.api.client.domain.broadcast.TxType.VOTE), + SIDE_VOTE(com.binance.dex.api.client.domain.broadcast.TxType.SIDE_VOTE), + DEPOSIT(com.binance.dex.api.client.domain.broadcast.TxType.DEPOSIT), + SIDE_DEPOSIT(com.binance.dex.api.client.domain.broadcast.TxType.SIDE_DEPOSIT), + MINT(com.binance.dex.api.client.domain.broadcast.TxType.MINT), + CREATE_VALIDATOR(com.binance.dex.api.client.domain.broadcast.TxType.CREATE_VALIDATOR), + REMOVE_VALIDATOR(com.binance.dex.api.client.domain.broadcast.TxType.REMOVE_VALIDATOR), + TIME_LOCK(com.binance.dex.api.client.domain.broadcast.TxType.TimeLock), + TIME_UNLOCK(com.binance.dex.api.client.domain.broadcast.TxType.TimeUnlock), + TIME_RELOCK(com.binance.dex.api.client.domain.broadcast.TxType.TimeRelock), + SET_ACCOUNT_FLAG(com.binance.dex.api.client.domain.broadcast.TxType.SetAccountFlag), + HTL_TRANSFER(com.binance.dex.api.client.domain.broadcast.TxType.HTL_TRANSFER), + DEPOSIT_HTL(com.binance.dex.api.client.domain.broadcast.TxType.DEPOSIT_HTL), + CLAIM_HTL(com.binance.dex.api.client.domain.broadcast.TxType.CLAIM_HTL), + REFUND_HTL(com.binance.dex.api.client.domain.broadcast.TxType.REFUND_HTL), + CREATE_SIDECHAIN_VALIDATOR(com.binance.dex.api.client.domain.broadcast.TxType.CREATE_SIDECHAIN_VALIDATOR), + EDIT_SIDECHAIN_VALIDATOR(com.binance.dex.api.client.domain.broadcast.TxType.EDIT_SIDECHAIN_VALIDATOR), + SIDECHAIN_DELEGATE(com.binance.dex.api.client.domain.broadcast.TxType.SIDECHAIN_DELEGATE), + SIDECHAIN_REDELEGATE(com.binance.dex.api.client.domain.broadcast.TxType.SIDECHAIN_REDELEGATE), + SIDECHAIN_UNDELEGATE(com.binance.dex.api.client.domain.broadcast.TxType.SIDECHAIN_UNBOND), + ORACLE_CLAIM(com.binance.dex.api.client.domain.broadcast.TxType.CLAIM), + CROSS_TRANSFER_OUT(com.binance.dex.api.client.domain.broadcast.TxType.TRANSFER_OUT), + CROSS_BIND(com.binance.dex.api.client.domain.broadcast.TxType.BIND), + CROSS_UNBIND(com.binance.dex.api.client.domain.broadcast.TxType.UNBIND), + BSC_SUBMIT_EVIDENCE(com.binance.dex.api.client.domain.broadcast.TxType.BSC_SUBMIT_EVIDENCE), + SIDECHAIN_UNJAIL(com.binance.dex.api.client.domain.broadcast.TxType.SIDECHAIN_UNJAIL), + TRANSFER_TOKEN_OWNERSHIP(com.binance.dex.api.client.domain.broadcast.TxType.TRANSFER_TOKEN_OWNERSHIP), + TINY_TOKEN_ISSUE(com.binance.dex.api.client.domain.broadcast.TxType.TINY_TOKEN_ISSUE), + MINI_TOKEN_ISSUE(com.binance.dex.api.client.domain.broadcast.TxType.MINI_TOKEN_ISSUE), + MINI_TOKEN_LIST(com.binance.dex.api.client.domain.broadcast.TxType.MINI_TOKEN_LIST), + MINI_TOKEN_SET_URI(com.binance.dex.api.client.domain.broadcast.TxType.MINI_TOKEN_SET_URI); + + private com.binance.dex.api.client.domain.broadcast.TxType code; + + TxType(com.binance.dex.api.client.domain.broadcast.TxType code) { + this.code = code; + } + + private static final Map nameTypeMap = new HashMap<>(); + + static { + for (TxType txType : TxType.values()) { + nameTypeMap.put(txType.name().toUpperCase(), txType.code); + } + } + + public static com.binance.dex.api.client.domain.broadcast.TxType getTypeByName(String name) { + if (name == null) { + return null; + } + return nameTypeMap.get(name.toUpperCase()); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FBscSubmitEvidenceConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FBscSubmitEvidenceConverter.java new file mode 100644 index 0000000..386f4e6 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FBscSubmitEvidenceConverter.java @@ -0,0 +1,27 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.domain.slash.BscSubmitEvidence; +import com.binance.dex.api.client.utils.converter.JsonUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + +import java.util.Map; + + +public class FBscSubmitEvidenceConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.BSC_SUBMIT_EVIDENCE; + } + + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + Map map = JsonUtil.fromJson(transactionV2.getData(), Map.class); + map.put("submitter", transactionV2.getFromAddr()); + transaction.setData(JsonUtil.toJson(map)); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FBurnConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FBurnConverter.java new file mode 100644 index 0000000..8a45900 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FBurnConverter.java @@ -0,0 +1,22 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.Burn; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + + +public class FBurnConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.BURN; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setValue(NumberUtil.longToBigDecimalString(transactionV2.getAmount())); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FCancelOrderConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FCancelOrderConverter.java new file mode 100644 index 0000000..2418172 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FCancelOrderConverter.java @@ -0,0 +1,39 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.CancelOrder; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.JsonUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; +import lombok.Builder; +import lombok.Data; + +import java.util.HashMap; +import java.util.Map; + + +public class FCancelOrderConverter extends TransactionConverter { + + public TxType getType() { + return TxType.CANCEL_ORDER; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + Map map = JsonUtil.fromJson(transactionV2.getData(), Map.class); + String symbol = (String) map.get("symbol"); + String orderId = (String) map.get("orderId"); + + Map newMap = new HashMap<>(); + newMap.put("orderData", CO.builder().symbol(symbol).orderId(orderId).build()); + transaction.setData(JsonUtil.toJson(newMap)); + } +} + +@Data +@Builder +class CO { + String symbol; + String orderId; +} \ No newline at end of file diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FClaimHtlConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FClaimHtlConverter.java new file mode 100644 index 0000000..d0efbd7 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FClaimHtlConverter.java @@ -0,0 +1,21 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.ClaimHashTimerLock; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + + +public class FClaimHtlConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.CLAIM_HTL; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setData(null); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FCreateSideChainValidatorConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FCreateSideChainValidatorConverter.java new file mode 100644 index 0000000..b77a5fe --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FCreateSideChainValidatorConverter.java @@ -0,0 +1,22 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.domain.stake.sidechain.CreateSideChainValidator; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + + +public class FCreateSideChainValidatorConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.CREATE_SIDECHAIN_VALIDATOR; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setValue(NumberUtil.longToBigDecimalString(transactionV2.getAmount())); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FCreateValidatorConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FCreateValidatorConverter.java new file mode 100644 index 0000000..298ec37 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FCreateValidatorConverter.java @@ -0,0 +1,23 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.CreateValidator; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + + +public class FCreateValidatorConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.CREATE_VALIDATOR; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setValue(NumberUtil.longToBigDecimalString(transactionV2.getAmount())); + transaction.setData(transactionV2.getData()); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FCrossBindConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FCrossBindConverter.java new file mode 100644 index 0000000..f8ebaf6 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FCrossBindConverter.java @@ -0,0 +1,33 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.bridge.Bind; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.JsonUtil; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + +import java.util.Map; + + +public class FCrossBindConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.BIND; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setValue(NumberUtil.longToBigDecimalString(transactionV2.getAmount())); + + Map map = JsonUtil.fromJson(transactionV2.getData(), Map.class); + map.put("symbol", transactionV2.getAsset()); + map.put("from", transactionV2.getFromAddr()); + map.put("amount", transactionV2.getAmount()); + + transaction.setData(JsonUtil.toJson(map)); + + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FCrossTransferOutConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FCrossTransferOutConverter.java new file mode 100644 index 0000000..6f40719 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FCrossTransferOutConverter.java @@ -0,0 +1,36 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.bridge.TransferOut; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.JsonUtil; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.Token; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + +import java.util.Map; + + +public class FCrossTransferOutConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.TRANSFER_OUT; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setValue(NumberUtil.longToBigDecimalString(transactionV2.getAmount())); + + Map map = JsonUtil.fromJson(transactionV2.getData(), Map.class); + map.put("from", transactionV2.getFromAddr()); + map.put("toAddress", transactionV2.getToAddr()); + + Token amount = Token.builder().denom(transactionV2.getAsset()).amount(transactionV2.getAmount()).build(); + map.put("amount", amount); + + transaction.setData(JsonUtil.toJson(map)); + } + +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FCrossUnBindConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FCrossUnBindConverter.java new file mode 100644 index 0000000..0580184 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FCrossUnBindConverter.java @@ -0,0 +1,28 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.bridge.Unbind; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.JsonUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + +import java.util.HashMap; +import java.util.Map; + + +public class FCrossUnBindConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.UNBIND; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + Map newMap = new HashMap<>(); + newMap.put("symbol", transactionV2.getAsset()); + newMap.put("from", transactionV2.getFromAddr()); + transaction.setData(JsonUtil.toJson(newMap)); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FDepositConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FDepositConverter.java new file mode 100644 index 0000000..95ea7ed --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FDepositConverter.java @@ -0,0 +1,24 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.Deposit; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + + +public class FDepositConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.DEPOSIT; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setValue(NumberUtil.longToBigDecimalString(transactionV2.getAmount())); + + transaction.setData(null); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FDepositHtlConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FDepositHtlConverter.java new file mode 100644 index 0000000..46d1c48 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FDepositHtlConverter.java @@ -0,0 +1,24 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.DepositHashTimerLock; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + + +public class FDepositHtlConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.DEPOSIT_HTL; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setValue(NumberUtil.longToBigDecimalString(transactionV2.getAmount())); + + transaction.setData(null); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FEditSideChainValidatorConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FEditSideChainValidatorConverter.java new file mode 100644 index 0000000..8ea937e --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FEditSideChainValidatorConverter.java @@ -0,0 +1,21 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.domain.stake.sidechain.EditSideChainValidator; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + + +public class FEditSideChainValidatorConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.EDIT_SIDECHAIN_VALIDATOR; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + return; + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FFreezeConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FFreezeConverter.java new file mode 100644 index 0000000..0bd777b --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FFreezeConverter.java @@ -0,0 +1,22 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.TokenFreeze; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + + +public class FFreezeConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.FREEZE_TOKEN; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setValue(NumberUtil.longToBigDecimalString(transactionV2.getAmount())); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FHtlTransferConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FHtlTransferConverter.java new file mode 100644 index 0000000..cc8554a --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FHtlTransferConverter.java @@ -0,0 +1,31 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.HashTimerLockTransfer; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.JsonUtil; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + +import java.util.Map; + + +public class FHtlTransferConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.HTL_TRANSFER; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setValue(NumberUtil.longToBigDecimalString(transactionV2.getAmount())); + transaction.setToAddr(transactionV2.getToAddr()); + + Map map = JsonUtil.fromJson(transactionV2.getData(), Map.class); + map.put("from", transactionV2.getFromAddr()); + map.put("to", transactionV2.getToAddr()); + transaction.setData(JsonUtil.toJson(map)); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FIssueTokenConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FIssueTokenConverter.java new file mode 100644 index 0000000..edf0601 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FIssueTokenConverter.java @@ -0,0 +1,28 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.Issue; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.JsonUtil; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + +import java.util.Map; + + +public class FIssueTokenConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.ISSUE; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + Map map = JsonUtil.fromJson(transactionV2.getData(), Map.class); + Long totalSupply = (Long) map.get("totalSupply"); + transaction.setValue(NumberUtil.longToBigDecimalString(totalSupply)); + transaction.setData(null); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FListingConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FListingConverter.java new file mode 100644 index 0000000..e0472eb --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FListingConverter.java @@ -0,0 +1,31 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.Listing; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.JsonUtil; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + +import java.util.Map; + +public class FListingConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.LISTING; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + Map map = JsonUtil.fromJson(transactionV2.getData(), Map.class); + Long initPrice = ((Number) map.get("initPrice")).longValue(); + transaction.setValue(NumberUtil.longToBigDecimalString(initPrice)); + + String asset = (String) map.get("baseAsset"); + transaction.setTxAsset(asset); + + transaction.setData(null); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FMiniTokenIssueConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FMiniTokenIssueConverter.java new file mode 100644 index 0000000..8dde7ae --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FMiniTokenIssueConverter.java @@ -0,0 +1,29 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.MiniTokenIssue; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.JsonUtil; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + +import java.util.Map; + + +public class FMiniTokenIssueConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.MINI_TOKEN_ISSUE; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + Map map = JsonUtil.fromJson(transactionV2.getData(), Map.class); + Long totalSupply = (Long) map.get("totalSupply"); + transaction.setValue(NumberUtil.longToBigDecimalString(totalSupply)); + + transaction.setData(null); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FMiniTokenListingConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FMiniTokenListingConverter.java new file mode 100644 index 0000000..478764b --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FMiniTokenListingConverter.java @@ -0,0 +1,32 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.MiniTokenListing; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.JsonUtil; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + +import java.util.Map; + + +public class FMiniTokenListingConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.MINI_TOKEN_LIST; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + Map map = JsonUtil.fromJson(transactionV2.getData(), Map.class); + Long initPrice = ((Number) map.get("initPrice")).longValue(); + transaction.setValue(NumberUtil.longToBigDecimalString(initPrice)); + + String asset = (String) map.get("baseAsset"); + transaction.setTxAsset(asset); + + transaction.setData(null); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FMiniTokenSetURIConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FMiniTokenSetURIConverter.java new file mode 100644 index 0000000..0c0d8f4 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FMiniTokenSetURIConverter.java @@ -0,0 +1,21 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.MiniTokenSetURI; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + + +public class FMiniTokenSetURIConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.MINI_TOKEN_SET_URI; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setData(null); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FMintConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FMintConverter.java new file mode 100644 index 0000000..5ac611e --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FMintConverter.java @@ -0,0 +1,24 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.Mint; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + + +public class FMintConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.MINT; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setValue(NumberUtil.longToBigDecimalString(transactionV2.getAmount())); + transaction.setData(null); + } +} + diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FNewOrderConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FNewOrderConverter.java new file mode 100644 index 0000000..276a438 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FNewOrderConverter.java @@ -0,0 +1,61 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.NewOrder; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.JsonUtil; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; +import lombok.Builder; +import lombok.Data; + +import java.math.BigDecimal; +import java.util.HashMap; +import java.util.Map; + + +public class FNewOrderConverter extends TransactionConverter { + + public TxType getType() { + return TxType.NEW_ORDER; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + Map map = JsonUtil.fromJson(transactionV2.getData(), Map.class); + String symbol = (String) map.get("symbol"); + String orderId = (String) map.get("orderId"); + String orderType = (String) map.get("orderType"); + String side = (String) map.get("side"); + String timeInForce = (String) map.get("timeInForce"); + String price = (String) map.get("price"); + String quantity = (String) map.get("quantity"); + + transaction.setOrderId(orderId); + transaction.setTxAsset(symbol.split("_")[0]); + + Map newMap = new HashMap<>(); + newMap.put("orderData", NO.builder().symbol(symbol).orderId(orderId) + .orderType(orderType).side(side).timeInForce(timeInForce) + .price(NumberUtil.longToBigDecimal(Long.parseLong(price)).stripTrailingZeros().toPlainString()) + .quantity(NumberUtil.longToBigDecimal(Long.parseLong(quantity)).stripTrailingZeros().toPlainString()) + .build()); + transaction.setData(JsonUtil.toJson(newMap)); + + BigDecimal value = NumberUtil.longToBigDecimal(Long.parseLong(price)).multiply(NumberUtil.longToBigDecimal(Long.parseLong(quantity)).setScale(8, BigDecimal.ROUND_HALF_UP)); + transaction.setValue(NumberUtil.decimalFormat(value)); + } +} + +@Data +@Builder +class NO { + String symbol; + String orderId; + String orderType; + String side; + String price; + String quantity; + String timeInForce; +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FOracleClaimConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FOracleClaimConverter.java new file mode 100644 index 0000000..210000f --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FOracleClaimConverter.java @@ -0,0 +1,21 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.domain.oracle.ClaimMsg; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + + +public class FOracleClaimConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.CLAIM; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setData(transactionV2.getData()); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FProposalConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FProposalConverter.java new file mode 100644 index 0000000..9e77a65 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FProposalConverter.java @@ -0,0 +1,33 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.SubmitProposal; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.JsonUtil; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + +import java.util.Map; + + +public class FProposalConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.SUBMIT_PROPOSAL; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setValue(NumberUtil.longToBigDecimalString(transactionV2.getAmount())); + + Map map = JsonUtil.fromJson(transactionV2.getData(), Map.class); + + map.remove("proposalId"); + map.remove("baseAssetSymbol"); + map.remove("quoteAssetSymbol"); + transaction.setData(JsonUtil.toJson(map)); + + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FRefundHtlConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FRefundHtlConverter.java new file mode 100644 index 0000000..9470fb0 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FRefundHtlConverter.java @@ -0,0 +1,21 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.RefundHashTimerLock; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + + +public class FRefundHtlConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.REFUND_HTL; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setData(null); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FRemoveValidatorConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FRemoveValidatorConverter.java new file mode 100644 index 0000000..04548ca --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FRemoveValidatorConverter.java @@ -0,0 +1,21 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.RemoveValidator; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + + +public class FRemoveValidatorConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.REMOVE_VALIDATOR; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setData(null); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FSetAccountFlagsConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FSetAccountFlagsConverter.java new file mode 100644 index 0000000..83f22e9 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FSetAccountFlagsConverter.java @@ -0,0 +1,31 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.SetAccountFlag; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.JsonUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + +import java.util.HashMap; +import java.util.Map; + + +public class FSetAccountFlagsConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.SetAccountFlag; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + Map map = JsonUtil.fromJson(transactionV2.getData(), Map.class); + Long flags = ((Number) map.get("flags")).longValue(); + + Map newMap = new HashMap<>(); + newMap.put("fromAddr", transactionV2.getFromAddr()); + newMap.put("flags", flags); + transaction.setData(JsonUtil.toJson(newMap)); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideChainDelegateConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideChainDelegateConverter.java new file mode 100644 index 0000000..2ecbb4b --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideChainDelegateConverter.java @@ -0,0 +1,39 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.domain.stake.sidechain.SideChainDelegate; +import com.binance.dex.api.client.utils.converter.JsonUtil; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.Token; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + +import java.util.Map; + + +public class FSideChainDelegateConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.SIDECHAIN_DELEGATE; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setValue(NumberUtil.longToBigDecimalString(transactionV2.getAmount())); + + Map map = JsonUtil.fromJson(transactionV2.getData(), Map.class); + if (transaction.getValue() == null || transaction.getTxAsset() == null) { + Token token = getToken(map, "amount"); + transaction.setTxAsset(token.getDenom()); + transaction.setValue(NumberUtil.longToBigDecimalString(token.getAmount())); + } + + map.put("delegatorAddress", map.get("delegatorAddr")); + map.put("validatorAddress", map.get("validatorAddr")); + map.remove("delegatorAddr"); + map.remove("validatorAddr"); + transaction.setData(JsonUtil.toJson(map)); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideChainRedelegateConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideChainRedelegateConverter.java new file mode 100644 index 0000000..1f193ae --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideChainRedelegateConverter.java @@ -0,0 +1,32 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.domain.stake.sidechain.SideChainRedelegate; +import com.binance.dex.api.client.utils.converter.JsonUtil; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.Token; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + +import java.util.Map; + +public class FSideChainRedelegateConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.SIDECHAIN_REDELEGATE; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setValue(NumberUtil.longToBigDecimalString(transactionV2.getAmount())); + + Map map = JsonUtil.fromJson(transactionV2.getData(), Map.class); + if (transaction.getValue() == null || transaction.getTxAsset() == null) { + Token token = getToken(map, "amount"); + transaction.setTxAsset(token.getDenom()); + transaction.setValue(NumberUtil.longToBigDecimalString(token.getAmount())); + } + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideChainUnJailConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideChainUnJailConverter.java new file mode 100644 index 0000000..5f90e12 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideChainUnJailConverter.java @@ -0,0 +1,21 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.domain.slash.SideChainUnJail; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + + +public class FSideChainUnJailConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.SIDECHAIN_UNJAIL; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + return; + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideChainUndelegateConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideChainUndelegateConverter.java new file mode 100644 index 0000000..9c8b009 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideChainUndelegateConverter.java @@ -0,0 +1,39 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.domain.stake.sidechain.SideChainUnBond; +import com.binance.dex.api.client.utils.converter.JsonUtil; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.Token; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + +import java.util.Map; + + +public class FSideChainUndelegateConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.SIDECHAIN_UNBOND; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setValue(NumberUtil.longToBigDecimalString(transactionV2.getAmount())); + + Map map = JsonUtil.fromJson(transactionV2.getData(), Map.class); + if (transaction.getValue() == null || transaction.getTxAsset() == null) { + Token token = getToken(map, "amount"); + transaction.setTxAsset(token.getDenom()); + transaction.setValue(NumberUtil.longToBigDecimalString(token.getAmount())); + } + + map.put("delegatorAddress", map.get("delegatorAddr")); + map.put("validatorAddress", map.get("validatorAddr")); + map.remove("delegatorAddr"); + map.remove("validatorAddr"); + transaction.setData(JsonUtil.toJson(map)); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideDepositConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideDepositConverter.java new file mode 100644 index 0000000..908d2c6 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideDepositConverter.java @@ -0,0 +1,21 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.SideDeposit; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + +public class FSideDepositConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.SIDE_DEPOSIT; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setValue(NumberUtil.longToBigDecimalString(transactionV2.getAmount())); + } +} \ No newline at end of file diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideProposalConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideProposalConverter.java new file mode 100644 index 0000000..a715471 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideProposalConverter.java @@ -0,0 +1,32 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.SideSubmitProposal; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.JsonUtil; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + +import java.util.Map; + + +public class FSideProposalConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.SIDE_SUBMIT_PROPOSAL; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setValue(NumberUtil.longToBigDecimalString(transactionV2.getAmount())); + + Map map = JsonUtil.fromJson(transactionV2.getData(), Map.class); + + map.remove("proposalId"); + map.remove("baseAssetSymbol"); + map.remove("quoteAssetSymbol"); + transaction.setData(JsonUtil.toJson(map)); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideVoteConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideVoteConverter.java new file mode 100644 index 0000000..7161fa4 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideVoteConverter.java @@ -0,0 +1,23 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.SideVote; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.TransactionConverter; +import lombok.extern.slf4j.Slf4j; + + +@Slf4j +public class FSideVoteConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.SIDE_VOTE; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + return; + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FTimeLockConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FTimeLockConverter.java new file mode 100644 index 0000000..0335615 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FTimeLockConverter.java @@ -0,0 +1,30 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.TimeLock; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.JsonUtil; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + +import java.util.Map; + + +public class FTimeLockConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.TimeLock; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setValue(NumberUtil.longToBigDecimalString(transactionV2.getAmount())); + + Map map = JsonUtil.fromJson(transactionV2.getData(), Map.class); + + map.remove("amount"); + transaction.setData(JsonUtil.toJson(map)); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FTimeReLockConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FTimeReLockConverter.java new file mode 100644 index 0000000..8476fc0 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FTimeReLockConverter.java @@ -0,0 +1,30 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.TimeRelock; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.JsonUtil; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + +import java.util.Map; + + +public class FTimeReLockConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.TimeRelock; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setValue(NumberUtil.longToBigDecimalString(transactionV2.getAmount())); + + Map map = JsonUtil.fromJson(transactionV2.getData(), Map.class); + + map.remove("amount"); + transaction.setData(JsonUtil.toJson(map)); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FTimeUnlockConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FTimeUnlockConverter.java new file mode 100644 index 0000000..3734fff --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FTimeUnlockConverter.java @@ -0,0 +1,21 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.TimeUnlock; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + + +public class FTimeUnlockConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.TimeUnlock; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + return; + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FTinyTokenIssueConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FTinyTokenIssueConverter.java new file mode 100644 index 0000000..29de6ba --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FTinyTokenIssueConverter.java @@ -0,0 +1,29 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.TinyTokenIssue; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.JsonUtil; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + +import java.util.Map; + + +public class FTinyTokenIssueConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.TINY_TOKEN_ISSUE; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + Map map = JsonUtil.fromJson(transactionV2.getData(), Map.class); + Long totalSupply = (Long) map.get("totalSupply"); + transaction.setValue(NumberUtil.longToBigDecimalString(totalSupply)); + + transaction.setData(null); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FTransferConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FTransferConverter.java new file mode 100644 index 0000000..cbafc41 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FTransferConverter.java @@ -0,0 +1,24 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.Transfer; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + + +public class FTransferConverter extends TransactionConverter { + + public TxType getType() { + return TxType.TRANSFER; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + if (transactionV2.getAmount() != null) { + transaction.setValue(NumberUtil.longToBigDecimalString(transactionV2.getAmount())); + } + transaction.setToAddr(transactionV2.getToAddr()); + } +} \ No newline at end of file diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FTransferOwnershipConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FTransferOwnershipConverter.java new file mode 100644 index 0000000..3655a19 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FTransferOwnershipConverter.java @@ -0,0 +1,31 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.TransferTokenOwnership; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.JsonUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + +import java.util.HashMap; +import java.util.Map; + + +public class FTransferOwnershipConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.TRANSFER_TOKEN_OWNERSHIP; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + Map map = new HashMap<>(); + map.put("from", transactionV2.getFromAddr()); + map.put("newOwner", transactionV2.getToAddr()); + map.put("symbol", transactionV2.getAsset()); + + transaction.setData(JsonUtil.toJson(map)); + } +} + diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FUnfreezeConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FUnfreezeConverter.java new file mode 100644 index 0000000..8afa79d --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FUnfreezeConverter.java @@ -0,0 +1,22 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.TokenUnfreeze; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + + +public class FUnfreezeConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.UNFREEZE_TOKEN; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setValue(NumberUtil.longToBigDecimalString(transactionV2.getAmount())); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FVoteConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FVoteConverter.java new file mode 100644 index 0000000..4d48f99 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FVoteConverter.java @@ -0,0 +1,23 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.domain.broadcast.Vote; +import com.binance.dex.api.client.utils.converter.TransactionConverter; +import lombok.extern.slf4j.Slf4j; + + +@Slf4j +public class FVoteConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.VOTE; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + return; + } +} diff --git a/src/test/java/com/binance/dex/api/client/examples/TransactionExample.java b/src/test/java/com/binance/dex/api/client/examples/TransactionExample.java new file mode 100644 index 0000000..3e68aea --- /dev/null +++ b/src/test/java/com/binance/dex/api/client/examples/TransactionExample.java @@ -0,0 +1,40 @@ +package com.binance.dex.api.client.examples; + +import com.binance.dex.api.client.BinanceDexApiClientFactory; +import com.binance.dex.api.client.BinanceDexApiRestClient; +import com.binance.dex.api.client.BinanceDexEnvironment; +import com.binance.dex.api.client.domain.*; +import com.binance.dex.api.client.domain.request.TransactionsRequest; +import com.binance.dex.api.client.utils.converter.TransactionConverterFactory; + +public class TransactionExample { + public static void main(String[] args) { + BinanceDexApiRestClient client = + BinanceDexApiClientFactory.newInstance().newRestClient(BinanceDexEnvironment.TEST_NET.getBaseUrl()); + + //Get transactions in last 24 hours + TransactionPageV2 transactions = client.getTransactions("tbnb135mqtf9gef879nmjlpwz6u2fzqcw4qlzrqwgvw"); + System.out.println(transactions); + + //Get transactions by criteria + TransactionsRequest request = new TransactionsRequest(); + request.setStartTime(1629272621945L); + request.setEndTime(1629359021945L); + request.setType("ORACLE_CLAIM"); + request.setAddress("tbnb135mqtf9gef879nmjlpwz6u2fzqcw4qlzrqwgvw"); + request.setAddressType("FROM"); + request.setOffset(5); + request.setLimit(1); + transactions = client.getTransactions(request); + System.out.println(transactions); + + //Get transaction a block + transactions = client.getTransactionsInBlock(15759101); + System.out.println(transactions); + + //Convert transaction to previous models + TransactionConverterFactory converterFactory = new TransactionConverterFactory(); + TransactionPage transactionPage = converterFactory.convert(transactions); + System.out.println(transactionPage); + } +} diff --git a/src/test/java/com/binance/dex/api/client/examples/TransactionExampleAsync.java b/src/test/java/com/binance/dex/api/client/examples/TransactionExampleAsync.java new file mode 100644 index 0000000..9dcca81 --- /dev/null +++ b/src/test/java/com/binance/dex/api/client/examples/TransactionExampleAsync.java @@ -0,0 +1,32 @@ +package com.binance.dex.api.client.examples; + +import com.binance.dex.api.client.BinanceDexApiAsyncRestClient; +import com.binance.dex.api.client.BinanceDexApiClientFactory; +import com.binance.dex.api.client.BinanceDexApiRestClient; +import com.binance.dex.api.client.BinanceDexEnvironment; +import com.binance.dex.api.client.domain.TransactionPageV2; +import com.binance.dex.api.client.domain.request.TransactionsRequest; + +public class TransactionExampleAsync { + public static void main(String[] args) { + BinanceDexApiAsyncRestClient client = + BinanceDexApiClientFactory.newInstance().newAsyncRestClient(BinanceDexEnvironment.TEST_NET.getBaseUrl()); + + //Get transactions in last 24 hours + client.getTransactions("tbnb135mqtf9gef879nmjlpwz6u2fzqcw4qlzrqwgvw", response -> System.out.println(response)); + + //Get transactions by criteria + TransactionsRequest request = new TransactionsRequest(); + request.setStartTime(1629272621945L); + request.setEndTime(1629359021945L); + request.setType("ORACLE_CLAIM"); + request.setAddress("tbnb135mqtf9gef879nmjlpwz6u2fzqcw4qlzrqwgvw"); + request.setAddressType("FROM"); + request.setOffset(5); + request.setLimit(1); + client.getTransactions(request, response -> System.out.println(response)); + + //Get transaction a block + client.getTransactionsInBlock(15759101, response -> System.out.println(response)); + } +} From 9f2cd391c280179fc2ab5ab9d779ca12cab95bcd Mon Sep 17 00:00:00 2001 From: forcodedancing Date: Thu, 19 Aug 2021 19:54:27 +0800 Subject: [PATCH 29/52] update junit version --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index ac92724..b3e3d08 100644 --- a/pom.xml +++ b/pom.xml @@ -70,7 +70,7 @@ junit junit - 4.12 + 4.13.1 test From 4aca1d6fe3d7556b0d527189ef22df79af3ed420 Mon Sep 17 00:00:00 2001 From: forcodedancing Date: Fri, 20 Aug 2021 10:23:12 +0800 Subject: [PATCH 30/52] update version --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index b3e3d08..749727e 100644 --- a/pom.xml +++ b/pom.xml @@ -5,7 +5,7 @@ com.binance.dex.api binance-dex-api-client - 1.1.2 + 1.1.3 2.6.0 From 3d47b57edcd31ce47d8f6bec832d044f531769fe Mon Sep 17 00:00:00 2001 From: forcodedancing Date: Fri, 20 Aug 2021 10:55:07 +0800 Subject: [PATCH 31/52] use the correct version --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index 749727e..b3e3d08 100644 --- a/pom.xml +++ b/pom.xml @@ -5,7 +5,7 @@ com.binance.dex.api binance-dex-api-client - 1.1.3 + 1.1.2 2.6.0 From 226cbde5aac93f53664a7997227fa81b141f7760 Mon Sep 17 00:00:00 2001 From: forcodedancing Date: Fri, 20 Aug 2021 13:49:42 +0800 Subject: [PATCH 32/52] set default value for confirm blocks --- .../api/client/utils/converter/TransactionConverterFactory.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/TransactionConverterFactory.java b/src/main/java/com/binance/dex/api/client/utils/converter/TransactionConverterFactory.java index e4a0491..b9b390f 100644 --- a/src/main/java/com/binance/dex/api/client/utils/converter/TransactionConverterFactory.java +++ b/src/main/java/com/binance/dex/api/client/utils/converter/TransactionConverterFactory.java @@ -160,7 +160,7 @@ public Transaction convert(TransactionV2 transactionV2) { transaction.setTxHash(transactionV2.getHash()); transaction.setTxType(transactionV2.getType()); transaction.setTimeStamp(formatter.format(new Date(transactionV2.getBlockTime()))); - + transaction.setConfirmBlocks(0L); transaction.setCode(transactionV2.getCode()); transaction.setMemo(transactionV2.getMemo()); From 2e7f3976d49ec53503783dfd47ba99af4a2f0eed Mon Sep 17 00:00:00 2001 From: forcodedancing Date: Fri, 20 Aug 2021 16:42:31 +0800 Subject: [PATCH 33/52] add changelogs --- CHANGELOG.md | 16 ++++++++++++++++ .../api/client/examples/TransactionExample.java | 4 +++- .../client/examples/TransactionExampleAsync.java | 1 + 3 files changed, 20 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 692aded..179a4ab 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,21 @@ # Changelog +## 1.1.2 +API UPGRADE +* [\#118](https://github.com/binance-chain/java-sdk/pull/118) [RPC] [API] deco old rest transactions api, and add new rest transaction apis + +Breaking Changes +* getTransactions(TransactionsRequest request) will return transactions with new data model TransactionPageV2 +* getTransactions(String address) will return transactions for an address in last 24 hours with new data model TransactionPageV2 + +Please refer to TransactionConverterFactory.java to see the mappings of the fields between TransactionPageV2 and TransactionPage + +Please refer to TransactionExample.java and [API Doc](https://docs.binance.org/api-reference/dex-api/block-service.html) for more details + +New API +* getTransactionsInBlock(long blockHeight) will return transaction in a specific block. + + ## 1.1.1 CHAIN UPGRADE * [\#105](https://github.com/binance-chain/java-sdk/pull/105) [RPC] [API] support for the transfer of token ownership, and decode the new types of oracle claim package diff --git a/src/test/java/com/binance/dex/api/client/examples/TransactionExample.java b/src/test/java/com/binance/dex/api/client/examples/TransactionExample.java index 3e68aea..2644797 100644 --- a/src/test/java/com/binance/dex/api/client/examples/TransactionExample.java +++ b/src/test/java/com/binance/dex/api/client/examples/TransactionExample.java @@ -3,7 +3,8 @@ import com.binance.dex.api.client.BinanceDexApiClientFactory; import com.binance.dex.api.client.BinanceDexApiRestClient; import com.binance.dex.api.client.BinanceDexEnvironment; -import com.binance.dex.api.client.domain.*; +import com.binance.dex.api.client.domain.TransactionPage; +import com.binance.dex.api.client.domain.TransactionPageV2; import com.binance.dex.api.client.domain.request.TransactionsRequest; import com.binance.dex.api.client.utils.converter.TransactionConverterFactory; @@ -17,6 +18,7 @@ public static void main(String[] args) { System.out.println(transactions); //Get transactions by criteria + //Refer to this for more: https://docs.binance.org/api-reference/dex-api/block-service.html#apiv1txs TransactionsRequest request = new TransactionsRequest(); request.setStartTime(1629272621945L); request.setEndTime(1629359021945L); diff --git a/src/test/java/com/binance/dex/api/client/examples/TransactionExampleAsync.java b/src/test/java/com/binance/dex/api/client/examples/TransactionExampleAsync.java index 9dcca81..c06f4ff 100644 --- a/src/test/java/com/binance/dex/api/client/examples/TransactionExampleAsync.java +++ b/src/test/java/com/binance/dex/api/client/examples/TransactionExampleAsync.java @@ -16,6 +16,7 @@ public static void main(String[] args) { client.getTransactions("tbnb135mqtf9gef879nmjlpwz6u2fzqcw4qlzrqwgvw", response -> System.out.println(response)); //Get transactions by criteria + //Refer to this for more: https://docs.binance.org/api-reference/dex-api/block-service.html#apiv1txs TransactionsRequest request = new TransactionsRequest(); request.setStartTime(1629272621945L); request.setEndTime(1629359021945L); From 4e08006dce3fdf39933a2eb524fcd56d559aba71 Mon Sep 17 00:00:00 2001 From: forcodedancing Date: Fri, 20 Aug 2021 17:28:44 +0800 Subject: [PATCH 34/52] update changelogs --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 179a4ab..17d790d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,7 +10,7 @@ Breaking Changes Please refer to TransactionConverterFactory.java to see the mappings of the fields between TransactionPageV2 and TransactionPage -Please refer to TransactionExample.java and [API Doc](https://docs.binance.org/api-reference/dex-api/block-service.html) for more details +Please refer to TransactionExample.java and [API Doc](https://docs.binance.org/api-reference/dex-api/block-service.html) for more details, the underlying API [Migration Guide](https://github.com/binance-chain/docs-site/blob/block-service/docs/api-reference/dex-api/migration-guide.md) could be also useful New API * getTransactionsInBlock(long blockHeight) will return transaction in a specific block. From 37f7b0167c09c688d3d10748eed63b224fff0349 Mon Sep 17 00:00:00 2001 From: forcodedancing Date: Mon, 23 Aug 2021 14:54:25 +0800 Subject: [PATCH 35/52] prepare release --- CHANGELOG.md | 2 +- README.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 17d790d..85a5ce8 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,7 +2,7 @@ ## 1.1.2 API UPGRADE -* [\#118](https://github.com/binance-chain/java-sdk/pull/118) [RPC] [API] deco old rest transactions api, and add new rest transaction apis +* [\#120](https://github.com/binance-chain/java-sdk/pull/120) [RPC] [API] deco old rest transactions api, and add new rest transaction apis Breaking Changes * getTransactions(TransactionsRequest request) will return transactions with new data model TransactionPageV2 diff --git a/README.md b/README.md index cb8f17f..3a8ab65 100644 --- a/README.md +++ b/README.md @@ -19,7 +19,7 @@ The Binance Chain Java SDK works as a lightweight Java library for interacting w com.binance.dex.api binance-dex-api-client - 1.1.0 + 1.1.2 ``` # Protobuf From 430c034b3e10d6e49aad7df1767ef4a198e769d1 Mon Sep 17 00:00:00 2001 From: RumeelHussainbnb <93580180+RumeelHussainbnb@users.noreply.github.com> Date: Mon, 13 Jun 2022 08:05:18 +0500 Subject: [PATCH 36/52] Updated Links to docs.bnbchain.org (#132) --- README.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index 3a8ab65..4cba31e 100644 --- a/README.md +++ b/README.md @@ -1,11 +1,11 @@ # Binance Chain Java SDK -The Binance Chain Java SDK works as a lightweight Java library for interacting with the [Binance Chain](https://binance-chain.github.io/api-reference/dex-api/paths.html). It provides a complete API coverage, and supports synchronous and asynchronous requests. It includes the following core components: +The Binance Chain Java SDK works as a lightweight Java library for interacting with the [Binance Chain](https://docs.bnbchain.org/docs/beaconchain/develop/api-reference/dex-api/paths). It provides a complete API coverage, and supports synchronous and asynchronous requests. It includes the following core components: -* **[crypto](https://github.com/binance-chain/java-sdk/blob/master/src/main/java/com/binance/dex/api/client/encoding/Crypto.java)** - core cryptographic functions. -* **[amino encoding](https://github.com/binance-chain/java-sdk/blob/master/src/main/java/com/binance/dex/api/client/encoding)** - [amino](https://github.com/binance-chain/docs-site/blob/master/docs/encoding.md) (protobuf-like) encoding and decoding of transactions. -* **[client](https://github.com/binance-chain/java-sdk/tree/master/src/main/java/com/binance/dex/api/client/impl)** - implementations of API rest client, supporting synchronous and asynchronous access to Binance Chain's REST APIs. -* **[wallet](https://github.com/binance-chain/java-sdk/blob/master/src/main/java/com/binance/dex/api/client/Wallet.java)** - management of accounts, including seed and encrypted mnemonic generation. +* **[crypto](https://github.com/bnb-chain/java-sdk/blob/master/src/main/java/com/binance/dex/api/client/encoding/Crypto.java)** - core cryptographic functions. +* **[amino encoding](https://github.com/bnb-chain/java-sdk/blob/master/src/main/java/com/binance/dex/api/client/encoding)** - [amino](https://docs.bnbchain.org/docs/beaconchain/learn/encoding/encoding/#amino) (protobuf-like) encoding and decoding of transactions. +* **[client](https://github.com/bnb-chain/java-sdk/tree/master/src/main/java/com/binance/dex/api/client/impl)** - implementations of API rest client, supporting synchronous and asynchronous access to Binance Chain's REST APIs. +* **[wallet](https://github.com/bnb-chain/java-sdk/blob/master/src/main/java/com/binance/dex/api/client/Wallet.java)** - management of accounts, including seed and encrypted mnemonic generation. ## Disclaimer **This branch is under active development, all subject to potential future change without notification and not ready for production use. The code and security audit have not been fully completed and not ready for any bug bounty.** @@ -34,11 +34,11 @@ More details please refer to https://github.com/xolstice/protobuf-maven-plugin # API -For examples, please check the [wiki](https://github.com/binance-chain/java-sdk/wiki). +For examples, please check the [wiki](https://github.com/bnb-chain/java-sdk/wiki). # Testing -All new code changes should be covered with unit tests. You can see the existing test cases here: https://github.com/binance-chain/java-sdk/tree/master/src/test/java/com/binance/dex/api/client/encoding +All new code changes should be covered with unit tests. You can see the existing test cases here: https://github.com/bnb-chain/java-sdk/tree/master/src/test/java/com/binance/dex/api/client/encoding # Contributing From 713c22497f25f3d4cb80a94e54126453a6c878e9 Mon Sep 17 00:00:00 2001 From: Roshan <48975233+Pythonberg1997@users.noreply.github.com> Date: Fri, 16 Sep 2022 10:50:10 +0800 Subject: [PATCH 37/52] Update cross chain package decode for BEP153 (#135) --- pom.xml | 2 +- .../api/client/crosschain/ContentEnum.java | 7 ++- .../dex/api/client/crosschain/Payload.java | 8 ++- .../crosschain/content/CrossStakeFailAck.java | 45 ++++++++++++++++ .../content/CrossStakeFailAckParamsBytes.java | 7 +++ .../crosschain/content/CrossStakeRefund.java | 24 +++++++++ .../crosschain/content/CrossStakeSyn.java | 53 +++++++++++++++++++ .../content/CrossStakeSynParamsBytes.java | 6 +++ .../RewardFailAckParamsBytes.java | 22 ++++++++ .../UndelegatedFailAckParamsBytes.java | 24 +++++++++ .../DelegateSynParamsBytes.java | 33 ++++++++++++ .../RedelegateSynParamsBytes.java | 36 +++++++++++++ .../UndelegateSynParamsBytes.java | 33 ++++++++++++ .../binance/dex/api/client/rlp/Decoder.java | 2 +- 14 files changed, 297 insertions(+), 5 deletions(-) create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/content/CrossStakeFailAck.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/content/CrossStakeFailAckParamsBytes.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/content/CrossStakeRefund.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/content/CrossStakeSyn.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/content/CrossStakeSynParamsBytes.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/content/crossStakeFailAckParamsBytes/RewardFailAckParamsBytes.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/content/crossStakeFailAckParamsBytes/UndelegatedFailAckParamsBytes.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/content/crossStakeSynParamsBytes/DelegateSynParamsBytes.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/content/crossStakeSynParamsBytes/RedelegateSynParamsBytes.java create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/content/crossStakeSynParamsBytes/UndelegateSynParamsBytes.java diff --git a/pom.xml b/pom.xml index b3e3d08..749727e 100644 --- a/pom.xml +++ b/pom.xml @@ -5,7 +5,7 @@ com.binance.dex.api binance-dex-api-client - 1.1.2 + 1.1.3 2.6.0 diff --git a/src/main/java/com/binance/dex/api/client/crosschain/ContentEnum.java b/src/main/java/com/binance/dex/api/client/crosschain/ContentEnum.java index 9239d1c..c2ce6f6 100644 --- a/src/main/java/com/binance/dex/api/client/crosschain/ContentEnum.java +++ b/src/main/java/com/binance/dex/api/client/crosschain/ContentEnum.java @@ -18,11 +18,14 @@ public enum ContentEnum { StakingCommonAckPack(8, 1, CommonAck.class), IbcValidatorSetPack(8, 2, IbcValidatorSet.class), GovCommonAckPack(9, 1, CommonAck.class), - SideDowntimeSlashPack(11, 0, com.binance.dex.api.client.crosschain.content.SideDowntimeSlash.class), + SideDowntimeSlashPack(11, 0, SideDowntimeSlash.class), MirrorSynPack(4, 0, MirrorSyn.class), MirrorSynAckPack(4, 1, MirrorAck.class), MirrorSyncSynPack(5, 0, MirrorSyncSyn.class), - MirrorSyncAckPack(5, 1, MirrorSyncAck.class) + MirrorSyncAckPack(5, 1, MirrorSyncAck.class), + CrossStakeSynPack(16, 0, CrossStakeSyn.class), + CrossStakeRefundPack(16, 1, CrossStakeRefund.class), + CrossStakeFailAckPack(16, 2, CrossStakeFailAck.class), ; private Integer channelId; diff --git a/src/main/java/com/binance/dex/api/client/crosschain/Payload.java b/src/main/java/com/binance/dex/api/client/crosschain/Payload.java index 97f026c..7e81ab8 100644 --- a/src/main/java/com/binance/dex/api/client/crosschain/Payload.java +++ b/src/main/java/com/binance/dex/api/client/crosschain/Payload.java @@ -35,10 +35,16 @@ public void decode(byte[] raw, Object superInstance) throws Exception { } Class clazz = ContentEnum.getClass(channelId, this.getPackageType()); + Content instance; if (clazz == null) { throw new RuntimeException(String.format("unknown content of channel id = %s, package type = %s", channelId, this.getPackageType())); } - Content instance = Decoder.decodeObject(ByteUtil.cut(raw, 33), clazz); + if (channelId == 16) { + instance = clazz.newInstance(); + instance = (Content) Decoder.decodeBytes(ByteUtil.cut(raw, 33), clazz, instance); + } else { + instance = Decoder.decodeObject(ByteUtil.cut(raw, 33), clazz); + } this.setContent(instance); } } diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/CrossStakeFailAck.java b/src/main/java/com/binance/dex/api/client/crosschain/content/CrossStakeFailAck.java new file mode 100644 index 0000000..78e8538 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/CrossStakeFailAck.java @@ -0,0 +1,45 @@ +package com.binance.dex.api.client.crosschain.content; + +import com.binance.dex.api.client.crosschain.Content; +import com.binance.dex.api.client.crosschain.content.crossStakeFailAckParamsBytes.*; +import com.binance.dex.api.client.crosschain.content.crossStakeSynParamsBytes.DelegateSynParamsBytes; +import com.binance.dex.api.client.crosschain.content.crossStakeSynParamsBytes.RedelegateSynParamsBytes; +import com.binance.dex.api.client.rlp.RlpDecodable; +import com.binance.dex.api.client.rlp.Decoder; +import com.binance.dex.api.client.encoding.ByteUtil; + +import lombok.Getter; +import lombok.Setter; + + +@Getter +@Setter +public class CrossStakeFailAck extends Content implements RlpDecodable { + + private CrossStakeFailAckParamsBytes paramsBytes; + + @Override + protected void setHrp(String hrp) { + this.paramsBytes.setHrp(hrp); + } + + @Override + public void decode(byte[] raw, Object superInstance) throws Exception { + if (raw.length < 16) { + throw new RuntimeException("Failed to code: too less length for cross stake syn package"); + } + + Class clazz; + CrossStakeFailAckParamsBytes instance; + if ((int) ByteUtil.pick(raw, 1, 1)[0] == 4) { + clazz = RewardFailAckParamsBytes.class; + instance = Decoder.decodeObject(raw, clazz); + } else if ((int) ByteUtil.pick(raw, 1, 1)[0] == 5) { + clazz = UndelegatedFailAckParamsBytes.class; + instance = Decoder.decodeObject(raw, clazz); + } else { + throw new RuntimeException("unknown event type of cross stake fail syn package"); + } + this.setParamsBytes(instance); + } +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/CrossStakeFailAckParamsBytes.java b/src/main/java/com/binance/dex/api/client/crosschain/content/CrossStakeFailAckParamsBytes.java new file mode 100644 index 0000000..96ff4f1 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/CrossStakeFailAckParamsBytes.java @@ -0,0 +1,7 @@ +package com.binance.dex.api.client.crosschain.content; + +public abstract class CrossStakeFailAckParamsBytes { + + protected abstract void setHrp(String hrp); + +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/CrossStakeRefund.java b/src/main/java/com/binance/dex/api/client/crosschain/content/CrossStakeRefund.java new file mode 100644 index 0000000..5e683d4 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/CrossStakeRefund.java @@ -0,0 +1,24 @@ +package com.binance.dex.api.client.crosschain.content; + +import com.binance.dex.api.client.crosschain.Content; +import com.binance.dex.api.client.crosschain.UnsignedInt; +import com.binance.dex.api.client.crosschain.UnsignedNumber; +import com.binance.dex.api.client.encoding.message.common.EthAddressValue; + +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +public class CrossStakeRefund extends Content { + + private UnsignedInt eventType; + private UnsignedNumber amount; + private EthAddressValue recipient; + private UnsignedInt errorCode; + + @Override + protected void setHrp(String hrp) { + + } +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/CrossStakeSyn.java b/src/main/java/com/binance/dex/api/client/crosschain/content/CrossStakeSyn.java new file mode 100644 index 0000000..054c477 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/CrossStakeSyn.java @@ -0,0 +1,53 @@ +package com.binance.dex.api.client.crosschain.content; + +import com.binance.dex.api.client.crosschain.Content; +import com.binance.dex.api.client.crosschain.content.crossStakeSynParamsBytes.*; +import com.binance.dex.api.client.encoding.ByteUtil; +import com.binance.dex.api.client.rlp.Decoder; +import com.binance.dex.api.client.rlp.RlpDecodable; + +import lombok.Getter; +import lombok.Setter; + + +@Getter +@Setter +public class CrossStakeSyn extends Content implements RlpDecodable { + + private Integer eventType; + private CrossStakeSynParamsBytes paramsBytes; + + public CrossStakeSyn(){} + + @Override + protected void setHrp(String hrp) { + this.paramsBytes.setHrp(hrp); + } + + @Override + public void decode(byte[] raw, Object superInstance) throws Exception { + if (raw.length < 27) { + throw new RuntimeException("Failed to code: too less length for cross stake syn package"); + } + + Class clazz; + CrossStakeSynParamsBytes instance; + if ((int) ByteUtil.pick(raw, 1, 1)[0] == 1) { + this.setEventType((int) ByteUtil.pick(raw, 1, 1)[0]); + clazz = DelegateSynParamsBytes.class; + instance = Decoder.decodeObject(ByteUtil.cut(raw, 3), clazz); + } else if ((int) ByteUtil.pick(raw, 1, 1)[0] == 2) { + this.setEventType((int) ByteUtil.pick(raw, 1, 1)[0]); + clazz = UndelegateSynParamsBytes.class; + instance = Decoder.decodeObject(ByteUtil.cut(raw, 3), clazz); + } else if ((int) ByteUtil.pick(raw, 2, 1)[0] == 3) { + this.setEventType((int) ByteUtil.pick(raw, 2, 1)[0]); + clazz = RedelegateSynParamsBytes.class; + instance = Decoder.decodeObject(ByteUtil.cut(raw, 5), clazz); + } else { + throw new RuntimeException(String.format("unknown event type of cross stake syn package, package type = %s", + this.getEventType())); + } + this.setParamsBytes(instance); + } +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/CrossStakeSynParamsBytes.java b/src/main/java/com/binance/dex/api/client/crosschain/content/CrossStakeSynParamsBytes.java new file mode 100644 index 0000000..1c1594d --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/CrossStakeSynParamsBytes.java @@ -0,0 +1,6 @@ +package com.binance.dex.api.client.crosschain.content; + +public abstract class CrossStakeSynParamsBytes { + + protected abstract void setHrp(String hrp); +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/crossStakeFailAckParamsBytes/RewardFailAckParamsBytes.java b/src/main/java/com/binance/dex/api/client/crosschain/content/crossStakeFailAckParamsBytes/RewardFailAckParamsBytes.java new file mode 100644 index 0000000..ffd821f --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/crossStakeFailAckParamsBytes/RewardFailAckParamsBytes.java @@ -0,0 +1,22 @@ +package com.binance.dex.api.client.crosschain.content.crossStakeFailAckParamsBytes; + +import com.binance.dex.api.client.crosschain.content.CrossStakeFailAckParamsBytes; +import com.binance.dex.api.client.encoding.message.common.EthAddressValue; +import com.binance.dex.api.client.crosschain.UnsignedNumber; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import lombok.Getter; +import lombok.Setter; + + +@Getter +@Setter +public class RewardFailAckParamsBytes extends CrossStakeFailAckParamsBytes { + + private Integer eventType; + private UnsignedNumber amount; + private EthAddressValue recipient; + + @Override + protected void setHrp(String hrp) { + } +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/crossStakeFailAckParamsBytes/UndelegatedFailAckParamsBytes.java b/src/main/java/com/binance/dex/api/client/crosschain/content/crossStakeFailAckParamsBytes/UndelegatedFailAckParamsBytes.java new file mode 100644 index 0000000..8657a64 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/crossStakeFailAckParamsBytes/UndelegatedFailAckParamsBytes.java @@ -0,0 +1,24 @@ +package com.binance.dex.api.client.crosschain.content.crossStakeFailAckParamsBytes; + +import com.binance.dex.api.client.crosschain.content.CrossStakeFailAckParamsBytes; +import com.binance.dex.api.client.encoding.message.common.EthAddressValue; +import com.binance.dex.api.client.crosschain.UnsignedNumber; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import lombok.Getter; +import lombok.Setter; + + +@Getter +@Setter +public class UndelegatedFailAckParamsBytes extends CrossStakeFailAckParamsBytes { + + private Integer eventType; + private UnsignedNumber amount; + private EthAddressValue recipient; + private Bech32AddressValue validator; + + @Override + protected void setHrp(String hrp) { + this.validator.setHrp(hrp); + } +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/crossStakeSynParamsBytes/DelegateSynParamsBytes.java b/src/main/java/com/binance/dex/api/client/crosschain/content/crossStakeSynParamsBytes/DelegateSynParamsBytes.java new file mode 100644 index 0000000..6d3955c --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/crossStakeSynParamsBytes/DelegateSynParamsBytes.java @@ -0,0 +1,33 @@ +package com.binance.dex.api.client.crosschain.content.crossStakeSynParamsBytes; + +import com.binance.dex.api.client.crosschain.content.CrossStakeSynParamsBytes; +import com.binance.dex.api.client.encoding.message.common.EthAddressValue; +import com.binance.dex.api.client.crosschain.UnsignedNumber; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.rlp.Decoder; +import com.binance.dex.api.client.rlp.RlpDecodable; +import lombok.Getter; +import lombok.Setter; + + +@Getter +@Setter +public class DelegateSynParamsBytes extends CrossStakeSynParamsBytes implements RlpDecodable { + + private EthAddressValue delAddr; + private Bech32AddressValue validator; + private UnsignedNumber amount; + + @Override + protected void setHrp(String hrp) { + this.validator.setHrp(hrp); + } + + @Override + public void decode(byte[] raw, Object superInstance) throws Exception { + DelegateSynParamsBytes vs = Decoder.decodeObject(raw, DelegateSynParamsBytes.class); + this.delAddr = vs.delAddr; + this.validator = vs.validator; + this.amount = vs.amount; + } +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/crossStakeSynParamsBytes/RedelegateSynParamsBytes.java b/src/main/java/com/binance/dex/api/client/crosschain/content/crossStakeSynParamsBytes/RedelegateSynParamsBytes.java new file mode 100644 index 0000000..d7ebb9b --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/crossStakeSynParamsBytes/RedelegateSynParamsBytes.java @@ -0,0 +1,36 @@ +package com.binance.dex.api.client.crosschain.content.crossStakeSynParamsBytes; + +import com.binance.dex.api.client.crosschain.content.CrossStakeSynParamsBytes; +import com.binance.dex.api.client.encoding.message.common.EthAddressValue; +import com.binance.dex.api.client.crosschain.UnsignedNumber; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.rlp.Decoder; +import com.binance.dex.api.client.rlp.RlpDecodable; +import lombok.Getter; +import lombok.Setter; + + +@Getter +@Setter +public class RedelegateSynParamsBytes extends CrossStakeSynParamsBytes implements RlpDecodable { + + private EthAddressValue delAddr; + private Bech32AddressValue valSrc; + private Bech32AddressValue valDst; + private UnsignedNumber amount; + + @Override + protected void setHrp(String hrp) { + this.valSrc.setHrp(hrp); + this.valDst.setHrp(hrp); + } + + @Override + public void decode(byte[] raw, Object superInstance) throws Exception { + RedelegateSynParamsBytes vs = Decoder.decodeObject(raw, RedelegateSynParamsBytes.class); + this.delAddr = vs.delAddr; + this.valSrc = vs.valSrc; + this.valDst = vs.valDst; + this.amount = vs.amount; + } +} diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/crossStakeSynParamsBytes/UndelegateSynParamsBytes.java b/src/main/java/com/binance/dex/api/client/crosschain/content/crossStakeSynParamsBytes/UndelegateSynParamsBytes.java new file mode 100644 index 0000000..bfb8402 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/crossStakeSynParamsBytes/UndelegateSynParamsBytes.java @@ -0,0 +1,33 @@ +package com.binance.dex.api.client.crosschain.content.crossStakeSynParamsBytes; + +import com.binance.dex.api.client.crosschain.content.CrossStakeSynParamsBytes; +import com.binance.dex.api.client.encoding.message.common.EthAddressValue; +import com.binance.dex.api.client.crosschain.UnsignedNumber; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.rlp.Decoder; +import com.binance.dex.api.client.rlp.RlpDecodable; +import lombok.Getter; +import lombok.Setter; + + +@Getter +@Setter +public class UndelegateSynParamsBytes extends CrossStakeSynParamsBytes implements RlpDecodable { + + private EthAddressValue delAddr; + private Bech32AddressValue validator; + private UnsignedNumber amount; + + @Override + protected void setHrp(String hrp) { + this.validator.setHrp(hrp); + } + + @Override + public void decode(byte[] raw, Object superInstance) throws Exception { + UndelegateSynParamsBytes vs = Decoder.decodeObject(raw, UndelegateSynParamsBytes.class); + this.delAddr = vs.delAddr; + this.validator = vs.validator; + this.amount = vs.amount; + } +} diff --git a/src/main/java/com/binance/dex/api/client/rlp/Decoder.java b/src/main/java/com/binance/dex/api/client/rlp/Decoder.java index 21d2c35..c21e9b4 100644 --- a/src/main/java/com/binance/dex/api/client/rlp/Decoder.java +++ b/src/main/java/com/binance/dex/api/client/rlp/Decoder.java @@ -43,7 +43,7 @@ public static T decodeObject(byte[] raw, Class clazz) throws Exception { } - private static Object decodeBytes(byte[] value, Class type, Object superInstance) throws Exception { + public static Object decodeBytes(byte[] value, Class type, Object superInstance) throws Exception { if (type == Integer.class) { return decodeInt(value, 0); From 1822340ef61b1a92ce54d6b92fd8fa41d5fbd474 Mon Sep 17 00:00:00 2001 From: jjos2372 <31958515+jjos2372@users.noreply.github.com> Date: Fri, 16 Sep 2022 00:22:42 -0300 Subject: [PATCH 38/52] Add ethereum repository to fix build problems (#108) --- pom.xml | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/pom.xml b/pom.xml index 749727e..cd8fe01 100644 --- a/pom.xml +++ b/pom.xml @@ -6,6 +6,13 @@ com.binance.dex.api binance-dex-api-client 1.1.3 + + + + jitpack.io + https://jitpack.io + + 2.6.0 @@ -105,9 +112,9 @@ - org.ethereum - ethereumj-core - 1.12.0-RELEASE + com.github.ethereum + ethereumj + 1.12.0 org.ethereum @@ -121,6 +128,10 @@ org.iq80.leveldb leveldb + + org.ethereum + leveldbjni-all + @@ -163,4 +174,4 @@ - \ No newline at end of file + From 18501ee957b3cce0f2a679200f3d1a9098db7274 Mon Sep 17 00:00:00 2001 From: Roshan <48975233+Pythonberg1997@users.noreply.github.com> Date: Fri, 16 Sep 2022 11:54:10 +0800 Subject: [PATCH 39/52] Update README.md (#136) --- README.md | 36 ++++++++++++++++++++---------------- 1 file changed, 20 insertions(+), 16 deletions(-) diff --git a/README.md b/README.md index 4cba31e..27d9b98 100644 --- a/README.md +++ b/README.md @@ -10,18 +10,26 @@ The Binance Chain Java SDK works as a lightweight Java library for interacting w ## Disclaimer **This branch is under active development, all subject to potential future change without notification and not ready for production use. The code and security audit have not been fully completed and not ready for any bug bounty.** -# Installation - - -1. Install library into your Maven's local repository by running `mvn install` -2. Add the following Maven dependency to your project's `pom.xml`: -``` - - com.binance.dex.api - binance-dex-api-client - 1.1.2 - -``` +# How to get + +1. Add the JitPack repository to your project's `pom.xml`: + ``` + + + jitpack.io + https://jitpack.io + + + ``` +2. Add the dependency: + ``` + + com.github.bnb-chain + java-sdk + Tag + + ``` + # Protobuf The protobuf-maven-plugin is used in this SDK. It is a plugin that integrates protocol buffers compiler (protoc) into Maven lifecycle. The Plugin generates Java source files from .proto (protocol buffer definition) files for this project by running `mvn compile`. @@ -30,8 +38,6 @@ These Java source files will be packaged into the final artifact and referenced More details please refer to https://github.com/xolstice/protobuf-maven-plugin - - # API For examples, please check the [wiki](https://github.com/bnb-chain/java-sdk/wiki). @@ -40,8 +46,6 @@ For examples, please check the [wiki](https://github.com/bnb-chain/java-sdk/wiki All new code changes should be covered with unit tests. You can see the existing test cases here: https://github.com/bnb-chain/java-sdk/tree/master/src/test/java/com/binance/dex/api/client/encoding - # Contributing Contributions to the Binance Chain Java SDK are welcome. Please ensure that you have tested the changes with a local client and have added unit test coverage for your code. - From 1ef436c93598c0a0a7bf89dad3b8a743cd95a330 Mon Sep 17 00:00:00 2001 From: "francis.l" Date: Tue, 27 Sep 2022 10:27:04 +0800 Subject: [PATCH 40/52] staking init --- .../api/client/BinanceDexApiNodeClient.java | 34 ++ .../dex/api/client/BinanceDexEnvironment.java | 10 + .../beaconchain/BeaconChainDelegate.java | 59 +++ .../beaconchain/BeaconChainDelegation.java | 46 ++ .../beaconchain/BeaconChainRedelegate.java | 63 +++ .../beaconchain/BeaconChainRedelegation.java | 167 +++++++ .../BeaconChainUnBondingDelegation.java | 117 +++++ .../beaconchain/BeaconChainUndelegate.java | 53 +++ .../beaconchain/BeaconChainValidator.java | 207 ++++++++ .../CreateBeaconChainValidator.java | 86 ++++ .../beaconchain/EditBeaconChainValidator.java | 64 +++ .../stake/sidechain/SideChainValidator.java | 21 + .../api/client/encoding/amino/WireType.java | 7 + .../query/BeaconChainRedelegationMessage.java | 171 +++++++ ...BeaconChainUnBondingDelegationMessage.java | 125 +++++ .../beaconchain/query/PoolMessage.java | 43 ++ .../BeaconChainDelegateMessage.java | 95 ++++ .../BeaconChainRedelegateMessage.java | 109 +++++ .../BeaconChainUndelegateMessage.java | 94 ++++ .../CreateBeaconChainValidatorMessage.java | 138 ++++++ .../EditBeaconChainValidatorMessage.java | 115 +++++ .../sidechain/query/BechValidator.java | 34 ++ .../query/QueryRedelegationParams.java | 67 +++ .../impl/BinanceDexApiNodeClientImpl.java | 107 +++++ .../NodeQueryDelegateBeaconChainStaking.java | 172 +++++++ .../NodeTxDelegateBeaconChainStaking.java | 172 +++++++ .../dex/api/client/encoding/AminoTest.java | 12 + .../BeaconChainStakingNodeExample.java | 450 ++++++++++++++++++ 28 files changed, 2838 insertions(+) create mode 100644 src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainDelegate.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainDelegation.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainRedelegate.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainRedelegation.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainUnBondingDelegation.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainUndelegate.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainValidator.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/CreateBeaconChainValidator.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/EditBeaconChainValidator.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/query/BeaconChainRedelegationMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/query/BeaconChainUnBondingDelegationMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/query/PoolMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/transaction/BeaconChainDelegateMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/transaction/BeaconChainRedelegateMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/transaction/BeaconChainUndelegateMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/transaction/CreateBeaconChainValidatorMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/transaction/EditBeaconChainValidatorMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryRedelegationParams.java create mode 100644 src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegateBeaconChainStaking.java create mode 100644 src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegateBeaconChainStaking.java create mode 100644 src/test/java/com/binance/dex/api/client/examples/BeaconChainStakingNodeExample.java diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java b/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java index 849484b..ce20b88 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java @@ -10,6 +10,7 @@ import com.binance.dex.api.client.domain.request.TradesRequest; import com.binance.dex.api.client.domain.request.TransactionsRequest; import com.binance.dex.api.client.domain.stake.Pool; +import com.binance.dex.api.client.domain.stake.beaconchain.*; import com.binance.dex.api.client.domain.stake.sidechain.*; import javax.annotation.Nullable; @@ -236,6 +237,39 @@ default List freeze(TokenFreeze freeze, Wallet wallet, Tran default List unfreeze(TokenUnfreeze unfreeze, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { throw new UnsupportedOperationException(); } + List createValidator(CreateBeaconChainValidator createBeaconChainValidator, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; + + List editValidator(EditBeaconChainValidator editBeaconChainValidator, Wallet wallet, TransactionOption option, boolean sync) throws IOException, NoSuchAlgorithmException ; + + List delegate(BeaconChainDelegate beaconChainDelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; + + List redelegate(BeaconChainRedelegate beaconChainRedelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; + + List undelegate(BeaconChainUndelegate beaconChainUndelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; + + BeaconChainValidator getValidator(String validatorAddress) throws IOException; + + List getTopValidators(int top) throws IOException ; + + BeaconChainDelegation getDelegation(String delegatorAddress, String validatorAddress) throws IOException; + + List getDelegations(String delegatorAddress) throws IOException; + + BeaconChainRedelegation getRedelegation(String delegatorAddress, String srcValidatorAddress, String dstValidatorAddress) throws IOException; + + List getRedelegations(String delegatorAddress) throws IOException; + + BeaconChainUnBondingDelegation getUnBondingDelegation(String delegatorAddress, String validatorAddress) throws IOException; + + List getUnBondingDelegations(String delegatorAddress) throws IOException; + + List getUnBondingDelegationsByValidator(String validatorAddress) throws IOException ; + + List getRedelegationsByValidator(String validatorAddress) throws IOException; + + Pool getPool() throws IOException; + + long getAllValidatorsCount(boolean jailInvolved) throws IOException; List createSideChainValidator(CreateSideChainValidator createSideChainValidator, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexEnvironment.java b/src/main/java/com/binance/dex/api/client/BinanceDexEnvironment.java index f049130..4b165ef 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexEnvironment.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexEnvironment.java @@ -23,6 +23,16 @@ public class BinanceDexEnvironment { "bva" ); + public static final BinanceDexEnvironment LOCAL_NET = new BinanceDexEnvironment( + "https://testnet-dex.binance.org", + "https://testnet-api.binance.org/bc/", + "wss://testnet-dex.binance.org/api", + "http://127.0.0.1:26657", + "wss://data-seed-pre-0-s3.binance.org/websocket", + "bnb", + "bva" + ); + // Rest API base URL private String baseUrl; // Chain transaction API base URL diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainDelegate.java b/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainDelegate.java new file mode 100644 index 0000000..9795bd9 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainDelegate.java @@ -0,0 +1,59 @@ +package com.binance.dex.api.client.domain.stake.beaconchain; + +import com.binance.dex.api.client.encoding.message.Token; + +/** + * @author Francis.Liu + **/ +public class BeaconChainDelegate { + + private String delegatorAddress; + + private String validatorAddress; + + private Token delegation; + + + public BeaconChainDelegate() { + } + + public BeaconChainDelegate(String delegatorAddress, String validatorAddress, Token delegation, String sideChainId) { + this.delegatorAddress = delegatorAddress; + this.validatorAddress = validatorAddress; + this.delegation = delegation; + } + + public String getDelegatorAddress() { + return delegatorAddress; + } + + public void setDelegatorAddress(String delegatorAddress) { + this.delegatorAddress = delegatorAddress; + } + + public String getValidatorAddress() { + return validatorAddress; + } + + public void setValidatorAddress(String validatorAddress) { + this.validatorAddress = validatorAddress; + } + + public Token getDelegation() { + return delegation; + } + + public void setDelegation(Token delegation) { + this.delegation = delegation; + } + + + @Override + public String toString() { + return "SideChainDelegate{" + + "delegatorAddress='" + delegatorAddress + '\'' + + ", validatorAddress='" + validatorAddress + '\'' + + ", delegation=" + delegation + + '}'; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainDelegation.java b/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainDelegation.java new file mode 100644 index 0000000..ac5da18 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainDelegation.java @@ -0,0 +1,46 @@ +package com.binance.dex.api.client.domain.stake.beaconchain; + +import com.binance.dex.api.client.domain.stake.sidechain.Delegation; +import com.binance.dex.api.client.domain.stake.sidechain.SideChainDelegation; +import com.binance.dex.api.client.encoding.message.Token; + +/** + * @author Francis.Liu + **/ +public class BeaconChainDelegation { + + private Delegation delegation; + + private Token balance; + + public BeaconChainDelegation() { + } + + public BeaconChainDelegation(Delegation delegation, Token balance) { + this.delegation = delegation; + this.balance = balance; + } + + public static BeaconChainDelegation createBySideChainDelegation(SideChainDelegation sideChainDelegation) { + BeaconChainDelegation delegation = new BeaconChainDelegation(); + delegation.setDelegation(sideChainDelegation.getDelegation()); + delegation.setBalance(sideChainDelegation.getBalance()); + return delegation; + } + + public Delegation getDelegation() { + return delegation; + } + + public void setDelegation(Delegation delegation) { + this.delegation = delegation; + } + + public Token getBalance() { + return balance; + } + + public void setBalance(Token balance) { + this.balance = balance; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainRedelegate.java b/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainRedelegate.java new file mode 100644 index 0000000..79bf8d3 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainRedelegate.java @@ -0,0 +1,63 @@ +package com.binance.dex.api.client.domain.stake.beaconchain; + +import com.binance.dex.api.client.encoding.message.Token; + +/** + * @author Francis.Liu + **/ +public class BeaconChainRedelegate { + + private String delegatorAddress; + + private String srcValidatorAddress; + + private String dstValidatorAddress; + + private Token amount; + + + public BeaconChainRedelegate() { + } + + public String getDelegatorAddress() { + return delegatorAddress; + } + + public void setDelegatorAddress(String delegatorAddress) { + this.delegatorAddress = delegatorAddress; + } + + public String getSrcValidatorAddress() { + return srcValidatorAddress; + } + + public void setSrcValidatorAddress(String srcValidatorAddress) { + this.srcValidatorAddress = srcValidatorAddress; + } + + public String getDstValidatorAddress() { + return dstValidatorAddress; + } + + public void setDstValidatorAddress(String dstValidatorAddress) { + this.dstValidatorAddress = dstValidatorAddress; + } + + public Token getAmount() { + return amount; + } + + public void setAmount(Token amount) { + this.amount = amount; + } + + @Override + public String toString() { + return "SideChainRedelegate{" + + "delegatorAddress='" + delegatorAddress + '\'' + + ", srcValidatorAddress='" + srcValidatorAddress + '\'' + + ", dstValidatorAddress='" + dstValidatorAddress + '\'' + + ", amount=" + amount + + '}'; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainRedelegation.java b/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainRedelegation.java new file mode 100644 index 0000000..7a4eeac --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainRedelegation.java @@ -0,0 +1,167 @@ +package com.binance.dex.api.client.domain.stake.beaconchain; + + +import com.binance.dex.api.client.domain.stake.sidechain.SideChainRedelegation; +import com.binance.dex.api.client.encoding.message.Token; + +/** + * @author Francis.Liu + **/ +public class BeaconChainRedelegation { + + //delegator address + private String delegatorAddress; + + //validator redelegation source operator address + private String srcValidatorAddress; + + //validator redelegation destination operator address + private String dstValidatorAddress; + + //height which the redelegation took place + private long createHeight; + + //unix time for redelegation completion + private String minTime; + + private long minTimeInMs; + + //initial balance when redelegation started + private Token initialBalance; + + //current balance + private Token balance; + + //amount of source shares redelegating + private long srcShares; + + //amount of destination shares redelegating + private long dstShare; + + public BeaconChainRedelegation() { + } + + public static BeaconChainRedelegation createBySideChainRedelegation(SideChainRedelegation sideChainRedelegation){ + BeaconChainRedelegation redelegation = new BeaconChainRedelegation(sideChainRedelegation.getDelegatorAddress(), + sideChainRedelegation.getSrcValidatorAddress(), + sideChainRedelegation.getDstValidatorAddress(), + sideChainRedelegation.getCreateHeight(), + sideChainRedelegation.getMinTime(), + sideChainRedelegation.getMinTimeInMs(), + sideChainRedelegation.getInitialBalance(), + sideChainRedelegation.getBalance(), + sideChainRedelegation.getSrcShares(), + sideChainRedelegation.getDstShare() + ); + return redelegation; + } + + public BeaconChainRedelegation(String delegatorAddress, String srcValidatorAddress, String dstValidatorAddress, long createHeight, String minTime, long minTimeInMs, Token initialBalance, Token balance, long srcShares, long dstShare) { + this.delegatorAddress = delegatorAddress; + this.srcValidatorAddress = srcValidatorAddress; + this.dstValidatorAddress = dstValidatorAddress; + this.createHeight = createHeight; + this.minTime = minTime; + this.minTimeInMs = minTimeInMs; + this.initialBalance = initialBalance; + this.balance = balance; + this.srcShares = srcShares; + this.dstShare = dstShare; + } + + public String getDelegatorAddress() { + return delegatorAddress; + } + + public void setDelegatorAddress(String delegatorAddress) { + this.delegatorAddress = delegatorAddress; + } + + public String getSrcValidatorAddress() { + return srcValidatorAddress; + } + + public void setSrcValidatorAddress(String srcValidatorAddress) { + this.srcValidatorAddress = srcValidatorAddress; + } + + public String getDstValidatorAddress() { + return dstValidatorAddress; + } + + public void setDstValidatorAddress(String dstValidatorAddress) { + this.dstValidatorAddress = dstValidatorAddress; + } + + public long getCreateHeight() { + return createHeight; + } + + public void setCreateHeight(long createHeight) { + this.createHeight = createHeight; + } + + public String getMinTime() { + return minTime; + } + + public void setMinTime(String minTime) { + this.minTime = minTime; + } + + public long getMinTimeInMs() { + return minTimeInMs; + } + + public void setMinTimeInMs(long minTimeInMs) { + this.minTimeInMs = minTimeInMs; + } + + public Token getInitialBalance() { + return initialBalance; + } + + public void setInitialBalance(Token initialBalance) { + this.initialBalance = initialBalance; + } + + public Token getBalance() { + return balance; + } + + public void setBalance(Token balance) { + this.balance = balance; + } + + public long getSrcShares() { + return srcShares; + } + + public void setSrcShares(long srcShares) { + this.srcShares = srcShares; + } + + public long getDstShare() { + return dstShare; + } + + public void setDstShare(long dstShare) { + this.dstShare = dstShare; + } + + @Override + public String toString() { + return "SideChainRedelegation{" + + "delegatorAddress='" + delegatorAddress + '\'' + + ", srcValidatorAddress='" + srcValidatorAddress + '\'' + + ", dstValidatorAddress='" + dstValidatorAddress + '\'' + + ", createHeight=" + createHeight + + ", minTime='" + minTime + '\'' + + ", minTimeInMs=" + minTimeInMs + + ", initialBalance=" + initialBalance + + ", balance=" + balance + + ", srcShares=" + srcShares + + ", dstShare=" + dstShare + + '}'; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainUnBondingDelegation.java b/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainUnBondingDelegation.java new file mode 100644 index 0000000..4f46efe --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainUnBondingDelegation.java @@ -0,0 +1,117 @@ +package com.binance.dex.api.client.domain.stake.beaconchain; + +import com.binance.dex.api.client.domain.stake.sidechain.UnBondingDelegation; +import com.binance.dex.api.client.encoding.message.Token; + +/** + * @author Francis.Liu + **/ +public class BeaconChainUnBondingDelegation { + + private String delegatorAddress; + + private String validatorAddress; + + private long createHeight; + + private long minTimeInMs; + + private String minTime; + + private Token initialBalance; + + private Token balance; + + public BeaconChainUnBondingDelegation(String delegatorAddress, String validatorAddress, long createHeight, long minTimeInMs, String minTime, Token initialBalance, Token balance) { + this.delegatorAddress = delegatorAddress; + this.validatorAddress = validatorAddress; + this.createHeight = createHeight; + this.minTimeInMs = minTimeInMs; + this.minTime = minTime; + this.initialBalance = initialBalance; + this.balance = balance; + } + + public static BeaconChainUnBondingDelegation createByUnBondingDelegation(UnBondingDelegation unBondingDelegation) { + BeaconChainUnBondingDelegation beaconChainRedelegation = new BeaconChainUnBondingDelegation( + unBondingDelegation.getDelegatorAddress(), + unBondingDelegation.getValidatorAddress(), + unBondingDelegation.getCreateHeight(), + unBondingDelegation.getMinTimeInMs(), + unBondingDelegation.getMinTime(), + unBondingDelegation.getInitialBalance(), + unBondingDelegation.getBalance() + + ); + return beaconChainRedelegation; + } + + public String getDelegatorAddress() { + return delegatorAddress; + } + + public void setDelegatorAddress(String delegatorAddress) { + this.delegatorAddress = delegatorAddress; + } + + public String getValidatorAddress() { + return validatorAddress; + } + + public void setValidatorAddress(String validatorAddress) { + this.validatorAddress = validatorAddress; + } + + public long getCreateHeight() { + return createHeight; + } + + public void setCreateHeight(long createHeight) { + this.createHeight = createHeight; + } + + public long getMinTimeInMs() { + return minTimeInMs; + } + + public void setMinTimeInMs(long minTimeInMs) { + this.minTimeInMs = minTimeInMs; + } + + public String getMinTime() { + return minTime; + } + + public void setMinTime(String minTime) { + this.minTime = minTime; + } + + public Token getInitialBalance() { + return initialBalance; + } + + public void setInitialBalance(Token initialBalance) { + this.initialBalance = initialBalance; + } + + public Token getBalance() { + return balance; + } + + public void setBalance(Token balance) { + this.balance = balance; + } + + @Override + public String toString() { + return "UnBondingDelegation{" + + "delegatorAddress='" + delegatorAddress + '\'' + + ", validatorAddress='" + validatorAddress + '\'' + + ", createHeight=" + createHeight + + ", minTimeInMs=" + minTimeInMs + + ", minTime='" + minTime + '\'' + + ", initialBalance=" + initialBalance + + ", balance=" + balance + + '}'; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainUndelegate.java b/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainUndelegate.java new file mode 100644 index 0000000..b63f94a --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainUndelegate.java @@ -0,0 +1,53 @@ +package com.binance.dex.api.client.domain.stake.beaconchain; + +import com.binance.dex.api.client.encoding.message.Token; + +/** + * @author Francis.Liu + **/ +public class BeaconChainUndelegate { + + private String delegatorAddress; + + private String validatorAddress; + + private Token amount; + + + public BeaconChainUndelegate() { + } + + public String getDelegatorAddress() { + return delegatorAddress; + } + + public void setDelegatorAddress(String delegatorAddress) { + this.delegatorAddress = delegatorAddress; + } + + public String getValidatorAddress() { + return validatorAddress; + } + + public void setValidatorAddress(String validatorAddress) { + this.validatorAddress = validatorAddress; + } + + public Token getAmount() { + return amount; + } + + public void setAmount(Token amount) { + this.amount = amount; + } + + + @Override + public String toString() { + return "SideChainUnBond{" + + "delegatorAddress='" + delegatorAddress + '\'' + + ", validatorAddress='" + validatorAddress + '\'' + + ", amount=" + amount + + '}'; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainValidator.java b/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainValidator.java new file mode 100644 index 0000000..4b2a826 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainValidator.java @@ -0,0 +1,207 @@ +package com.binance.dex.api.client.domain.stake.beaconchain; + +import com.binance.dex.api.client.domain.stake.Commission; +import com.binance.dex.api.client.domain.stake.Description; +import com.binance.dex.api.client.domain.stake.sidechain.SideChainValidator; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; + +import java.util.ArrayList; + +/** + * @author Francis.Liu + **/ +public class BeaconChainValidator { + + private String feeAddr; + private String operatorAddr; + private byte[] consPubKey; + private boolean jailed; + private int status; + private long tokens; + private long delegatorShares; + private Description description; + private long bondHeight; + private int bondIntraTxCounter; + private long unBondingHeight; + private long unBondingMinTime; + private Commission commission; + private String distributionAddr; + + private ArrayList stakeSnapShots; + + private String accumulatedStake; + + + public BeaconChainValidator() { + } + + public static BeaconChainValidator createBySideChainValidator(SideChainValidator sideChainValidator) { + BeaconChainValidator validator = new BeaconChainValidator(); + validator.setFeeAddr(sideChainValidator.getFeeAddr()); + validator.setOperatorAddr(sideChainValidator.getOperatorAddr()); + validator.setConsPubKey(sideChainValidator.getConsPubKey()); + validator.setJailed(sideChainValidator.isJailed()); + validator.setStatus(sideChainValidator.getStatus()); + validator.setTokens(sideChainValidator.getTokens()); + validator.setDelegatorShares(sideChainValidator.getDelegatorShares()); + validator.setDescription(sideChainValidator.getDescription()); + validator.setBondHeight(sideChainValidator.getBondHeight()); + validator.setBondIntraTxCounter(sideChainValidator.getBondIntraTxCounter()); + validator.setUnBondingHeight(sideChainValidator.getUnBondingHeight()); + validator.setCommission(sideChainValidator.getCommission()); + validator.setStakeSnapShots(sideChainValidator.getStakeSnapShots()); + validator.setAccumulatedStake(sideChainValidator.getAccumulatedStake()); + return validator; + } + + public String getFeeAddr() { + return feeAddr; + } + + public void setFeeAddr(String feeAddr) { + this.feeAddr = feeAddr; + } + + public String getOperatorAddr() { + return operatorAddr; + } + + public void setOperatorAddr(String operatorAddr) { + this.operatorAddr = operatorAddr; + } + + public byte[] getConsPubKey() { + return consPubKey; + } + + public void setConsPubKey(byte[] consPubKey) { + this.consPubKey = consPubKey; + } + + public boolean isJailed() { + return jailed; + } + + public void setJailed(boolean jailed) { + this.jailed = jailed; + } + + public int getStatus() { + return status; + } + + public void setStatus(int status) { + this.status = status; + } + + public long getTokens() { + return tokens; + } + + public void setTokens(long tokens) { + this.tokens = tokens; + } + + public long getDelegatorShares() { + return delegatorShares; + } + + public void setDelegatorShares(long delegatorShares) { + this.delegatorShares = delegatorShares; + } + + public Description getDescription() { + return description; + } + + public void setDescription(Description description) { + this.description = description; + } + + public long getBondHeight() { + return bondHeight; + } + + public void setBondHeight(long bondHeight) { + this.bondHeight = bondHeight; + } + + public int getBondIntraTxCounter() { + return bondIntraTxCounter; + } + + public void setBondIntraTxCounter(int bondIntraTxCounter) { + this.bondIntraTxCounter = bondIntraTxCounter; + } + + public long getUnBondingHeight() { + return unBondingHeight; + } + + public void setUnBondingHeight(long unBondingHeight) { + this.unBondingHeight = unBondingHeight; + } + + public long getUnBondingMinTime() { + return unBondingMinTime; + } + + public void setUnBondingMinTime(long unBondingMinTime) { + this.unBondingMinTime = unBondingMinTime; + } + + public Commission getCommission() { + return commission; + } + + public void setCommission(Commission commission) { + this.commission = commission; + } + + public String getDistributionAddr() { + return distributionAddr; + } + + public void setDistributionAddr(String distributionAddr) { + this.distributionAddr = distributionAddr; + } + + public ArrayList getStakeSnapShots() { + return stakeSnapShots; + } + + public void setStakeSnapShots(ArrayList stakeSnapShots) { + this.stakeSnapShots = stakeSnapShots; + } + + public String getAccumulatedStake() { + return accumulatedStake; + } + + public void setAccumulatedStake(String accumulatedStake) { + this.accumulatedStake = accumulatedStake; + } + + @Override + public String toString() { + return "SideChainValidator{" + + "feeAddr=" + feeAddr + '\n' + + ", operatorAddr=" + operatorAddr + '\n' + + ", consPubKey='" + consPubKey + '\'' + '\n' + + ", jailed=" + jailed + '\n' + + ", status=" + status + '\n' + + ", tokens=" + tokens + '\n' + + ", delegatorShares=" + delegatorShares + '\n' + + ", description=" + description + '\n' + + ", bondHeight=" + bondHeight + '\n' + + ", bondIntraTxCounter=" + bondIntraTxCounter + '\n' + + ", unBondingHeight=" + unBondingHeight + '\n' + + ", unBondingMinTime=" + unBondingMinTime + '\n' + + ", commission=" + commission + '\n' + + ", distributionAddr=" + distributionAddr + '\n' + + '}'; + } + +} diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/CreateBeaconChainValidator.java b/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/CreateBeaconChainValidator.java new file mode 100644 index 0000000..61bff16 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/CreateBeaconChainValidator.java @@ -0,0 +1,86 @@ +package com.binance.dex.api.client.domain.stake.beaconchain; + +import com.binance.dex.api.client.domain.stake.Commission; +import com.binance.dex.api.client.domain.stake.Description; +import com.binance.dex.api.client.encoding.message.Token; + +/** + * @author Francis.Liu + **/ +public class CreateBeaconChainValidator { + + private Description description; + + private Commission commission; + + private String delegatorAddr; + + private String validatorAddr; + + private Token delegation; + + private String pubKey; + + + public CreateBeaconChainValidator() { + } + + public Description getDescription() { + return description; + } + + public void setDescription(Description description) { + this.description = description; + } + + public Commission getCommission() { + return commission; + } + + public void setCommission(Commission commission) { + this.commission = commission; + } + + public String getDelegatorAddr() { + return delegatorAddr; + } + + public void setDelegatorAddr(String delegatorAddr) { + this.delegatorAddr = delegatorAddr; + } + + public Token getDelegation() { + return delegation; + } + + public void setDelegation(Token delegation) { + this.delegation = delegation; + } + public String getPubKey() { + return pubKey; + } + + public void setPubKey(String pubKey) { + this.pubKey = pubKey; + } + + public String getValidatorAddr() { + return validatorAddr; + } + + public void setValidatorAddr(String validatorAddr) { + this.validatorAddr = validatorAddr; + } + + @Override + public String toString() { + return "CreateSideChainValidator{" + '\n' + + "description=" + description + '\n' + + ", commission=" + commission + '\n' + + ", delegatorAddr='" + delegatorAddr + '\'' + '\n' + + ", validatorAddr='" + validatorAddr + '\'' + '\n' + + ", delegation=" + delegation + '\n' + + ", pubKey='" + pubKey + '\'' + '\n' + + '}'; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/EditBeaconChainValidator.java b/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/EditBeaconChainValidator.java new file mode 100644 index 0000000..dbb63b1 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/EditBeaconChainValidator.java @@ -0,0 +1,64 @@ +package com.binance.dex.api.client.domain.stake.beaconchain; + +import com.binance.dex.api.client.domain.stake.Description; +import com.binance.dex.api.client.encoding.amino.types.PubKeyEd25519; +import com.fasterxml.jackson.annotation.JsonProperty; + +/** + * @author Francis.Liu + **/ +public class EditBeaconChainValidator { + + private Description description; + + private String validatorAddress; + + private long commissionRate; + + public String getPubKey() { + return pubKey; + } + + public void setPubKey(String pubKey) { + this.pubKey = pubKey; + } + + private String pubKey; + + public EditBeaconChainValidator() { + } + + public Description getDescription() { + return description; + } + + public void setDescription(Description description) { + this.description = description; + } + + public String getValidatorAddress() { + return validatorAddress; + } + + public void setValidatorAddress(String validatorAddress) { + this.validatorAddress = validatorAddress; + } + + public long getCommissionRate() { + return commissionRate; + } + + public void setCommissionRate(long commissionRate) { + this.commissionRate = commissionRate; + } + + + @Override + public String toString() { + return "EditSideChainValidator{" + + "description=" + description + "\n" + + ", validatorAddress='" + validatorAddress + '\'' + "\n" + + ", commissionRate=" + commissionRate + "\n" + + '}'; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainValidator.java b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainValidator.java index c691268..1944dba 100644 --- a/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainValidator.java +++ b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainValidator.java @@ -3,6 +3,7 @@ import com.binance.dex.api.client.domain.stake.Commission; import com.binance.dex.api.client.domain.stake.Description; +import java.util.ArrayList; import java.util.Arrays; /** @@ -44,6 +45,26 @@ public class SideChainValidator { private String sideFeeAddr; + public ArrayList getStakeSnapShots() { + return stakeSnapShots; + } + + public void setStakeSnapShots(ArrayList stakeSnapShots) { + this.stakeSnapShots = stakeSnapShots; + } + + public String getAccumulatedStake() { + return accumulatedStake; + } + + public void setAccumulatedStake(String accumulatedStake) { + this.accumulatedStake = accumulatedStake; + } + + private ArrayList stakeSnapShots; + + private String accumulatedStake; + public SideChainValidator() { } diff --git a/src/main/java/com/binance/dex/api/client/encoding/amino/WireType.java b/src/main/java/com/binance/dex/api/client/encoding/amino/WireType.java index 9c0f885..c8e4fed 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/amino/WireType.java +++ b/src/main/java/com/binance/dex/api/client/encoding/amino/WireType.java @@ -1,6 +1,7 @@ package com.binance.dex.api.client.encoding.amino; import com.binance.dex.api.client.encoding.amino.types.PubKeyEd25519; +import com.binance.dex.api.client.encoding.message.beaconchain.transaction.*; import com.binance.dex.api.client.encoding.message.bridge.BindMsgMessage; import com.binance.dex.api.client.encoding.message.bridge.ClaimMsgMessage; import com.binance.dex.api.client.encoding.message.bridge.TransferOutMsgMessage; @@ -22,6 +23,12 @@ public class WireType { static { classToTypeName.put(PubKeyEd25519.class, "tendermint/PubKeyEd25519"); + classToTypeName.put(CreateBeaconChainValidatorMessage.class, "cosmos-sdk/MsgCreateValidatorOpen"); + classToTypeName.put(EditBeaconChainValidatorMessage.class, "cosmos-sdk/MsgEditValidator"); + classToTypeName.put(BeaconChainDelegateMessage.class, "cosmos-sdk/MsgDelegate"); + classToTypeName.put(BeaconChainRedelegateMessage.class, "cosmos-sdk/MsgRedelegate"); + classToTypeName.put(BeaconChainUndelegateMessage.class, "cosmos-sdk/MsgUndelegate"); + classToTypeName.put(CreateSideChainValidatorMessage.class, "cosmos-sdk/MsgCreateSideChainValidator"); classToTypeName.put(EditSideChainValidatorMessage.class, "cosmos-sdk/MsgEditSideChainValidator"); classToTypeName.put(SideChainDelegateMessage.class, "cosmos-sdk/MsgSideChainDelegate"); diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/query/BeaconChainRedelegationMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/query/BeaconChainRedelegationMessage.java new file mode 100644 index 0000000..ca0c251 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/query/BeaconChainRedelegationMessage.java @@ -0,0 +1,171 @@ +package com.binance.dex.api.client.encoding.message.beaconchain.query; + + +import com.binance.dex.api.client.domain.stake.beaconchain.BeaconChainRedelegation; +import com.binance.dex.api.client.domain.stake.sidechain.SideChainRedelegation; +import com.binance.dex.api.client.encoding.message.Token; +import com.fasterxml.jackson.annotation.JsonProperty; + +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.Date; + +/** + * @author Francis.Liu + **/ +public class BeaconChainRedelegationMessage { + + //delegator address + @JsonProperty(value = "delegator_addr") + private String delegatorAddress; + + //validator redelegation source operator address + @JsonProperty(value = "validator_src_addr") + private String srcValidatorAddress; + + //validator redelegation destination operator address + @JsonProperty(value = "validator_dst_addr") + private String dstValidatorAddress; + + //height which the redelegation took place + @JsonProperty(value = "creation_height") + private long createHeight; + + //unix time for redelegation completion + @JsonProperty(value = "min_time") + private String minTime; + + //initial balance when redelegation started + @JsonProperty(value = "initial_balance") + private Token initialBalance; + + //current balance + @JsonProperty(value = "balance") + private Token balance; + + //amount of source shares redelegating + @JsonProperty(value = "shares_src") + private long srcShares; + + //amount of destination shares redelegating + @JsonProperty(value = "shares_dst") + private long dstShare; + + public BeaconChainRedelegationMessage() { + } + + public BeaconChainRedelegation toBeaconChainRedelegation(){ + BeaconChainRedelegation redelegation = new BeaconChainRedelegation(this.getDelegatorAddress(), + this.getSrcValidatorAddress(), + this.getDstValidatorAddress(), + this.getCreateHeight(), + this.getMinTime(), + this.getMinTimeInMs(), + this.getInitialBalance(), + this.getBalance(), + this.getSrcShares(), + this.getDstShare() + ); + return redelegation; + } + + + public String getDelegatorAddress() { + return delegatorAddress; + } + + public void setDelegatorAddress(String delegatorAddress) { + this.delegatorAddress = delegatorAddress; + } + + public String getSrcValidatorAddress() { + return srcValidatorAddress; + } + + public void setSrcValidatorAddress(String srcValidatorAddress) { + this.srcValidatorAddress = srcValidatorAddress; + } + + public String getDstValidatorAddress() { + return dstValidatorAddress; + } + + public void setDstValidatorAddress(String dstValidatorAddress) { + this.dstValidatorAddress = dstValidatorAddress; + } + + public long getCreateHeight() { + return createHeight; + } + + public void setCreateHeight(long createHeight) { + this.createHeight = createHeight; + } + + public String getMinTime() { + return minTime; + } + + public void setMinTime(String minTime) { + this.minTime = minTime; + } + + public long getMinTimeInMs() { + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss"); + Date d = null; + try { + d = sdf.parse(this.minTime); + } catch (ParseException e) { + return 0; + } + return d.getTime(); + } + + + public Token getInitialBalance() { + return initialBalance; + } + + public void setInitialBalance(Token initialBalance) { + this.initialBalance = initialBalance; + } + + public Token getBalance() { + return balance; + } + + public void setBalance(Token balance) { + this.balance = balance; + } + + public long getSrcShares() { + return srcShares; + } + + public void setSrcShares(long srcShares) { + this.srcShares = srcShares; + } + + public long getDstShare() { + return dstShare; + } + + public void setDstShare(long dstShare) { + this.dstShare = dstShare; + } + + @Override + public String toString() { + return "SideChainRedelegation{" + + "delegatorAddress='" + delegatorAddress + '\'' + + ", srcValidatorAddress='" + srcValidatorAddress + '\'' + + ", dstValidatorAddress='" + dstValidatorAddress + '\'' + + ", createHeight=" + createHeight + + ", minTime='" + minTime + '\'' + + ", initialBalance=" + initialBalance + + ", balance=" + balance + + ", srcShares=" + srcShares + + ", dstShare=" + dstShare + + '}'; + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/query/BeaconChainUnBondingDelegationMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/query/BeaconChainUnBondingDelegationMessage.java new file mode 100644 index 0000000..ca6d1ea --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/query/BeaconChainUnBondingDelegationMessage.java @@ -0,0 +1,125 @@ +package com.binance.dex.api.client.encoding.message.beaconchain.query; + +import com.binance.dex.api.client.domain.stake.beaconchain.BeaconChainUnBondingDelegation; +import com.binance.dex.api.client.domain.stake.sidechain.UnBondingDelegation; +import com.binance.dex.api.client.encoding.message.Token; +import com.fasterxml.jackson.annotation.JsonProperty; + +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.Date; + +/** + * @author Francis.Liu + **/ +public class BeaconChainUnBondingDelegationMessage { + @JsonProperty(value = "delegator_addr") + private String delegatorAddress; + @JsonProperty(value = "validator_addr") + private String validatorAddress; + @JsonProperty(value = "creation_height") + private long createHeight; + @JsonProperty(value = "min_time") + private String minTime; + @JsonProperty(value = "initial_balance") + private Token initialBalance; + @JsonProperty(value = "balance") + private Token balance; + + @JsonProperty(value = "cross_stake") + private boolean crossStake; + + public BeaconChainUnBondingDelegation toBeaconChainUnBondingDelegation() { + BeaconChainUnBondingDelegation beaconChainRedelegation = new BeaconChainUnBondingDelegation( + this.getDelegatorAddress(), + this.getValidatorAddress(), + this.getCreateHeight(), + this.getMinTimeInMs(), + this.getMinTime(), + this.getInitialBalance(), + this.getBalance() + + ); + return beaconChainRedelegation; + } + + public String getDelegatorAddress() { + return delegatorAddress; + } + + public void setDelegatorAddress(String delegatorAddress) { + this.delegatorAddress = delegatorAddress; + } + + public String getValidatorAddress() { + return validatorAddress; + } + + public void setValidatorAddress(String validatorAddress) { + this.validatorAddress = validatorAddress; + } + + public long getCreateHeight() { + return createHeight; + } + + public void setCreateHeight(long createHeight) { + this.createHeight = createHeight; + } + + public long getMinTimeInMs() { + SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss"); + Date d = null; + try { + d = sdf.parse(this.minTime); + } catch (ParseException e) { + return 0; + } + return d.getTime(); + } + + + public String getMinTime() { + return minTime; + } + + public void setMinTime(String minTime) { + this.minTime = minTime; + } + + public Token getInitialBalance() { + return initialBalance; + } + + public void setInitialBalance(Token initialBalance) { + this.initialBalance = initialBalance; + } + + public Token getBalance() { + return balance; + } + + public void setBalance(Token balance) { + this.balance = balance; + } + + public boolean isCrossStake() { + return crossStake; + } + + public void setCrossStake(boolean crossStake) { + this.crossStake = crossStake; + } + + @Override + public String toString() { + return "UnBondingDelegation{" + + "delegatorAddress='" + delegatorAddress + '\'' + + ", validatorAddress='" + validatorAddress + '\'' + + ", createHeight=" + createHeight + + ", minTime='" + minTime + '\'' + + ", initialBalance=" + initialBalance + + ", balance=" + balance + + '}'; + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/query/PoolMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/query/PoolMessage.java new file mode 100644 index 0000000..3b09162 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/query/PoolMessage.java @@ -0,0 +1,43 @@ +package com.binance.dex.api.client.encoding.message.beaconchain.query; + +import com.binance.dex.api.client.domain.stake.Pool; +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.common.Dec; +import com.fasterxml.jackson.annotation.JsonProperty; + +import java.util.ArrayList; + +/** + * @author Francis.Liu + **/ +public class PoolMessage { + @JsonProperty(value = "loose_tokens") + private long looseTokens; + @JsonProperty(value = "bonded_tokens") + private long bondedTokens; + + public long getLooseTokens() { + return looseTokens; + } + + public void setLooseTokens(long looseTokens) { + this.looseTokens = looseTokens; + } + + public long getBondedTokens() { + return bondedTokens; + } + + public void setBondedTokens(long bondedTokens) { + this.bondedTokens = bondedTokens; + } + + public Pool toPool(){ + Pool pool = new Pool(); + pool.setBondedTokens(bondedTokens); + pool.setLooseTokens(looseTokens); + return pool; + } + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/transaction/BeaconChainDelegateMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/transaction/BeaconChainDelegateMessage.java new file mode 100644 index 0000000..3e5c361 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/transaction/BeaconChainDelegateMessage.java @@ -0,0 +1,95 @@ +package com.binance.dex.api.client.encoding.message.beaconchain.transaction; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.encoding.message.common.CoinValueStr; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import org.apache.commons.lang3.StringUtils; + +import java.util.ArrayList; + +/** + * @author Francis.Liu + **/ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class BeaconChainDelegateMessage implements BinanceDexTransactionMessage, AminoSerializable { + + @JsonProperty(value = "delegator_addr") + private Bech32AddressValue delegatorAddress; + + @JsonProperty(value = "validator_addr") + private Bech32AddressValue validatorAddress; + + @JsonProperty(value = "delegation") + private CoinValueStr delegation; + + + public BeaconChainDelegateMessage() { } + + public Bech32AddressValue getDelegatorAddress() { + return delegatorAddress; + } + + public void setDelegatorAddress(Bech32AddressValue delegatorAddress) { + this.delegatorAddress = delegatorAddress; + } + + public Bech32AddressValue getValidatorAddress() { + return validatorAddress; + } + + public void setValidatorAddress(Bech32AddressValue validatorAddress) { + this.validatorAddress = validatorAddress; + } + + public CoinValueStr getDelegation() { + return delegation; + } + + public void setDelegation(CoinValueStr delegation) { + this.delegation = delegation; + } + + + @Override + public AminoSerializable newAminoMessage() { + return new BeaconChainDelegateMessage(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(Bech32AddressValue.class, delegatorAddress, delegatorAddress == null || delegatorAddress.isDefaultOrEmpty()) + .addField(Bech32AddressValue.class, validatorAddress, validatorAddress == null || validatorAddress.isDefaultOrEmpty()) + .addField(CoinValueStr.class, delegation, delegation == null) + .build(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + delegatorAddress = ((Bech32AddressValue) value); + break; + case 2: + validatorAddress = ((Bech32AddressValue) value); + break; + case 3: + delegation = ((CoinValueStr) value); + break; + default: + break; + } + } + + @Override + public boolean useAminoJson() { + return true; + } + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/transaction/BeaconChainRedelegateMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/transaction/BeaconChainRedelegateMessage.java new file mode 100644 index 0000000..08ecdb6 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/transaction/BeaconChainRedelegateMessage.java @@ -0,0 +1,109 @@ +package com.binance.dex.api.client.encoding.message.beaconchain.transaction; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.encoding.message.common.CoinValueStr; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import org.apache.commons.lang3.StringUtils; + +import java.util.ArrayList; + +/** + * @author Francis.Liu + **/ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class BeaconChainRedelegateMessage implements BinanceDexTransactionMessage, AminoSerializable { + + @JsonProperty(value = "delegator_addr") + private Bech32AddressValue delegatorAddress; + + @JsonProperty(value = "validator_src_addr") + private Bech32AddressValue srcValidatorAddress; + + @JsonProperty(value = "validator_dst_addr") + private Bech32AddressValue dstValidatorAddress; + + @JsonProperty(value = "amount") + private CoinValueStr amount; + + public BeaconChainRedelegateMessage() { + } + + @Override + public AminoSerializable newAminoMessage() { + return new BeaconChainRedelegateMessage(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(Bech32AddressValue.class, delegatorAddress, delegatorAddress == null || delegatorAddress.isDefaultOrEmpty()) + .addField(Bech32AddressValue.class, srcValidatorAddress, srcValidatorAddress == null || srcValidatorAddress.isDefaultOrEmpty()) + .addField(Bech32AddressValue.class, dstValidatorAddress, dstValidatorAddress == null || dstValidatorAddress.isDefaultOrEmpty()) + .addField(CoinValueStr.class, amount, amount == null) + .build(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + delegatorAddress = ((Bech32AddressValue) value); + break; + case 2: + srcValidatorAddress = ((Bech32AddressValue) value); + break; + case 3: + dstValidatorAddress = ((Bech32AddressValue) value); + break; + case 4: + amount = ((CoinValueStr) value); + break; + default: + break; + } + } + + @Override + public boolean useAminoJson() { + return true; + } + + public Bech32AddressValue getDelegatorAddress() { + return delegatorAddress; + } + + public void setDelegatorAddress(Bech32AddressValue delegatorAddress) { + this.delegatorAddress = delegatorAddress; + } + + public Bech32AddressValue getSrcValidatorAddress() { + return srcValidatorAddress; + } + + public void setSrcValidatorAddress(Bech32AddressValue srcValidatorAddress) { + this.srcValidatorAddress = srcValidatorAddress; + } + + public Bech32AddressValue getDstValidatorAddress() { + return dstValidatorAddress; + } + + public void setDstValidatorAddress(Bech32AddressValue dstValidatorAddress) { + this.dstValidatorAddress = dstValidatorAddress; + } + + public CoinValueStr getAmount() { + return amount; + } + + public void setAmount(CoinValueStr amount) { + this.amount = amount; + } + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/transaction/BeaconChainUndelegateMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/transaction/BeaconChainUndelegateMessage.java new file mode 100644 index 0000000..f2ba7ec --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/transaction/BeaconChainUndelegateMessage.java @@ -0,0 +1,94 @@ +package com.binance.dex.api.client.encoding.message.beaconchain.transaction; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.encoding.message.common.CoinValueStr; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import org.apache.commons.lang3.StringUtils; + +import java.util.ArrayList; + +/** + * @author Francis.Liu + **/ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class BeaconChainUndelegateMessage implements BinanceDexTransactionMessage, AminoSerializable { + + @JsonProperty(value = "delegator_addr") + private Bech32AddressValue delegatorAddress; + + @JsonProperty(value = "validator_addr") + private Bech32AddressValue validatorAddress; + + @JsonProperty(value = "amount") + private CoinValueStr amount; + + public BeaconChainUndelegateMessage() { + } + + @Override + public boolean useAminoJson() { + return true; + } + + @Override + public AminoSerializable newAminoMessage() { + return new BeaconChainUndelegateMessage(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(Bech32AddressValue.class, delegatorAddress, delegatorAddress == null || delegatorAddress.isDefaultOrEmpty()) + .addField(Bech32AddressValue.class, validatorAddress, validatorAddress == null || validatorAddress.isDefaultOrEmpty()) + .addField(CoinValueStr.class, amount, amount == null) + .build(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + delegatorAddress = ((Bech32AddressValue) value); + break; + case 2: + validatorAddress = ((Bech32AddressValue) value); + break; + case 3: + amount = ((CoinValueStr) value); + break; + default: + break; + } + } + + public Bech32AddressValue getDelegatorAddress() { + return delegatorAddress; + } + + public void setDelegatorAddress(Bech32AddressValue delegatorAddress) { + this.delegatorAddress = delegatorAddress; + } + + public Bech32AddressValue getValidatorAddress() { + return validatorAddress; + } + + public void setValidatorAddress(Bech32AddressValue validatorAddress) { + this.validatorAddress = validatorAddress; + } + + public CoinValueStr getAmount() { + return amount; + } + + public void setAmount(CoinValueStr amount) { + this.amount = amount; + } + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/transaction/CreateBeaconChainValidatorMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/transaction/CreateBeaconChainValidatorMessage.java new file mode 100644 index 0000000..2a8cecd --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/transaction/CreateBeaconChainValidatorMessage.java @@ -0,0 +1,138 @@ +package com.binance.dex.api.client.encoding.message.beaconchain.transaction; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.encoding.message.common.CoinValueStr; +import com.binance.dex.api.client.encoding.message.sidechain.value.CommissionMsgValue; +import com.binance.dex.api.client.encoding.message.sidechain.value.DescriptionValue; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import org.apache.commons.lang3.StringUtils; + +import java.util.ArrayList; + +/** + * @author Francis.Liu + **/ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class CreateBeaconChainValidatorMessage implements BinanceDexTransactionMessage, AminoSerializable { + + @JsonProperty(value = "description") + private DescriptionValue description = new DescriptionValue(); + + @JsonProperty(value = "commission") + private CommissionMsgValue commission = new CommissionMsgValue(); + + @JsonProperty(value = "delegator_address") + private Bech32AddressValue delegatorAddr; + + @JsonProperty(value = "validator_address") + private Bech32AddressValue validatorOperatorAddr; + + @JsonProperty(value = "pubkey") + private String pubKey; + + @JsonProperty(value = "delegation") + private CoinValueStr delegation; + + + @Override + public boolean useAminoJson() { + return true; + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + description = ((DescriptionValue) value); + break; + case 2: + commission = ((CommissionMsgValue) value); + break; + case 3: + delegatorAddr = ((Bech32AddressValue) value); + break; + case 4: + validatorOperatorAddr = ((Bech32AddressValue) value); + break; + case 5: + pubKey = ((String) value); + break; + case 6: + delegation = ((CoinValueStr) value); + break; + default: + break; + } + } + + @Override + public AminoSerializable newAminoMessage() { + return new CreateBeaconChainValidatorMessage(); + } + + @Override + public ArrayList> IterateFields() { + ArrayList> fields = new ArrayList<>(); + fields.add(new AminoField<>(DescriptionValue.class, description, description == null)); + fields.add(new AminoField<>(CommissionMsgValue.class, commission, commission == null)); + fields.add(new AminoField<>(Bech32AddressValue.class, delegatorAddr, delegatorAddr == null || delegatorAddr.isDefaultOrEmpty())); + fields.add(new AminoField<>(Bech32AddressValue.class, validatorOperatorAddr, validatorOperatorAddr == null || validatorOperatorAddr.isDefaultOrEmpty())); + fields.add(new AminoField<>(String.class, pubKey, StringUtils.isEmpty(pubKey))); + fields.add(new AminoField<>(CoinValueStr.class, delegation, delegation == null)); + return fields; + } + + public DescriptionValue getDescription() { + return description; + } + + public void setDescription(DescriptionValue description) { + this.description = description; + } + + public CommissionMsgValue getCommission() { + return commission; + } + + public void setCommission(CommissionMsgValue commission) { + this.commission = commission; + } + + public Bech32AddressValue getDelegatorAddr() { + return delegatorAddr; + } + + public void setDelegatorAddr(Bech32AddressValue delegatorAddr) { + this.delegatorAddr = delegatorAddr; + } + + public Bech32AddressValue getValidatorOperatorAddr() { + return validatorOperatorAddr; + } + + public void setValidatorOperatorAddr(Bech32AddressValue validatorOperatorAddr) { + this.validatorOperatorAddr = validatorOperatorAddr; + } + + public CoinValueStr getDelegation() { + return delegation; + } + + public void setDelegation(CoinValueStr delegation) { + this.delegation = delegation; + } + + public String getPubKey() { + return pubKey; + } + + public void setPubKey(String pubKey) { + this.pubKey = pubKey; + } +} \ No newline at end of file diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/transaction/EditBeaconChainValidatorMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/transaction/EditBeaconChainValidatorMessage.java new file mode 100644 index 0000000..5f5fb9d --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/transaction/EditBeaconChainValidatorMessage.java @@ -0,0 +1,115 @@ +package com.binance.dex.api.client.encoding.message.beaconchain.transaction; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.encoding.message.common.Dec; +import com.binance.dex.api.client.encoding.message.sidechain.value.DescriptionValue; +import com.binance.dex.api.client.encoding.serializer.DecToStringSerializer; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import org.apache.commons.lang3.StringUtils; + +import java.util.ArrayList; + +/** + * @author Francis.Liu + **/ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class EditBeaconChainValidatorMessage implements BinanceDexTransactionMessage, AminoSerializable { + + @JsonProperty(value = "description") + private DescriptionValue description; + + @JsonProperty(value = "address") + private Bech32AddressValue validatorOperatorAddress; + + @JsonProperty(value = "commission_rate") + @JsonSerialize(using = DecToStringSerializer.class) + private Dec commissionRate; + + @JsonProperty(value = "pubkey") + private String pubKey; + + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + description = ((DescriptionValue) value); + break; + case 2: + validatorOperatorAddress = ((Bech32AddressValue) value); + break; + case 3: + commissionRate = ((Dec) value); + break; + case 4: + pubKey = ((String) value); + break; + default: + break; + } + } + + public EditBeaconChainValidatorMessage() { + } + + public DescriptionValue getDescription() { + return description; + } + + public void setDescription(DescriptionValue description) { + this.description = description; + } + + public Bech32AddressValue getValidatorOperatorAddress() { + return validatorOperatorAddress; + } + + public void setValidatorOperatorAddress(Bech32AddressValue validatorOperatorAddress) { + this.validatorOperatorAddress = validatorOperatorAddress; + } + + public Dec getCommissionRate() { + return commissionRate; + } + + public void setCommissionRate(Dec commissionRate) { + this.commissionRate = commissionRate; + } + + public String getPubKey() { + return pubKey; + } + + public void setPubKey(String pubKey) { + this.pubKey = pubKey; + } + + @Override + public boolean useAminoJson() { + return true; + } + + @Override + public AminoSerializable newAminoMessage() { + return new EditBeaconChainValidatorMessage(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(DescriptionValue.class, description, description == null) + .addField(Bech32AddressValue.class, validatorOperatorAddress, validatorOperatorAddress == null || validatorOperatorAddress.isDefaultOrEmpty()) + .addField(Dec.class, commissionRate, commissionRate == null || commissionRate.isDefaultOrEmpty()) +// .addField(Dec.class, commissionRate, false) + .addField(String.class, pubKey, StringUtils.isEmpty(pubKey)) + .build(); + } + +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/BechValidator.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/BechValidator.java index 9244f23..179e8f6 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/BechValidator.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/BechValidator.java @@ -9,6 +9,8 @@ import com.fasterxml.jackson.annotation.JsonProperty; import org.apache.commons.lang3.StringUtils; +import java.util.ArrayList; + /** * @author Fitz.Lu **/ @@ -115,6 +117,28 @@ public void setUpdateTime(String updateTime) { @JsonProperty(value = "side_fee_addr") private String sideFeeAddr; + @JsonProperty(value = "stake_snapshots") + private ArrayList stakeSnapShots; + + public ArrayList getStakeSnapShots() { + return stakeSnapShots; + } + + public void setStakeSnapShots(ArrayList stakeSnapShots) { + this.stakeSnapShots = stakeSnapShots; + } + + public String getAccumulatedStake() { + return accumulatedStake; + } + + public void setAccumulatedStake(String accumulatedStake) { + this.accumulatedStake = accumulatedStake; + } + + @JsonProperty(value = "accumulated_stake") + private String accumulatedStake; + public BechValidator() { } @@ -175,6 +199,16 @@ public SideChainValidator toSideChainValidator() { } } + if(stakeSnapShots != null && stakeSnapShots.size() > 0){ + ArrayList stakeSnapShots = new ArrayList<>(); + for(String stakeSnapShot : stakeSnapShots){ + stakeSnapShots.add(stakeSnapShot); + } + validator.setStakeSnapShots(stakeSnapShots); + } + + validator.setAccumulatedStake(accumulatedStake); + return validator; } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryRedelegationParams.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryRedelegationParams.java new file mode 100644 index 0000000..9f90109 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/QueryRedelegationParams.java @@ -0,0 +1,67 @@ +package com.binance.dex.api.client.encoding.message.sidechain.query; + +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; + +/** + * @author Francis.Liu + **/ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class QueryRedelegationParams extends BaseQueryParams { + + @JsonProperty(value = "DelegatorAddr") + private String delegatorAddr; + + @JsonProperty(value = "ValSrcAddr") + private String validatorSrcAddr; + + @JsonProperty(value = "ValDstAddr") + private String validatorDstAddr; + + public QueryRedelegationParams() { + } + + public QueryRedelegationParams(String sideChainId, String delegatorAddr, String validatorSrcAddr, String validatorDstAddr) { + super(sideChainId); + this.delegatorAddr = delegatorAddr; + this.validatorSrcAddr = validatorSrcAddr; + this.validatorDstAddr = validatorDstAddr; + } + + + public String getSideChainId() { + return sideChainId; + } + + public void setSideChainId(String sideChainId) { + this.sideChainId = sideChainId; + } + + public String getDelegatorAddr() { + return delegatorAddr; + } + + public void setDelegatorAddr(String delegatorAddr) { + this.delegatorAddr = delegatorAddr; + } + + public String getValidatorSrcAddr() { + return validatorSrcAddr; + } + + public void setValidatorSrcAddr(String validatorSrcAddr) { + this.validatorSrcAddr = validatorSrcAddr; + } + + public String getValidatorDstAddr() { + return validatorDstAddr; + } + + public void setValidatorDstAddr(String validatorDstAddr) { + this.validatorDstAddr = validatorDstAddr; + } + +} + diff --git a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java index e2312f4..abb0f1d 100644 --- a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java +++ b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java @@ -7,6 +7,7 @@ import com.binance.dex.api.client.domain.oracle.Prophecy; import com.binance.dex.api.client.domain.StakeValidator; import com.binance.dex.api.client.domain.stake.Pool; +import com.binance.dex.api.client.domain.stake.beaconchain.*; import com.binance.dex.api.client.domain.stake.sidechain.*; import com.binance.dex.api.client.domain.broadcast.Transaction; import com.binance.dex.api.client.domain.broadcast.*; @@ -53,10 +54,14 @@ public class BinanceDexApiNodeClientImpl implements BinanceDexApiNodeClient { private final NodeTxDelegateSideChainStaking sideChainStakingTxDelegate; + private final NodeTxDelegateBeaconChainStaking beaconChainStakingTxDelegate; + private final NodeTxDelegateBridge bridgeTxDelegate; private final NodeQueryDelegateSideChainStaking sideChainQueryDelegate; + private final NodeQueryDelegateBeaconChainStaking beaconChainQueryDelegate; + private final NodeQueryDelegateOracle oracleQueryDelegate; public BinanceDexApiNodeClientImpl(String nodeUrl, String hrp, String valHrp) { @@ -67,8 +72,10 @@ public BinanceDexApiNodeClientImpl(String nodeUrl, String hrp, String valHrp) { feeConverter = new FeeConverter(); sideChainStakingTxDelegate = new NodeTxDelegateSideChainStaking(binanceDexNodeApi, hrp, valHrp); + beaconChainStakingTxDelegate = new NodeTxDelegateBeaconChainStaking(binanceDexNodeApi, hrp, valHrp); bridgeTxDelegate = new NodeTxDelegateBridge(binanceDexNodeApi, hrp, valHrp); sideChainQueryDelegate = new NodeQueryDelegateSideChainStaking(binanceDexNodeApi, hrp, valHrp); + beaconChainQueryDelegate = new NodeQueryDelegateBeaconChainStaking(binanceDexNodeApi, hrp, valHrp, sideChainQueryDelegate); oracleQueryDelegate = new NodeQueryDelegateOracle(binanceDexNodeApi, hrp, valHrp); } @@ -586,6 +593,106 @@ public com.binance.dex.api.client.domain.MiniToken getMiniTokenInfoBySymbol(Stri } } + @Override + public List createValidator(CreateBeaconChainValidator createBeaconChainValidator, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + synchronized (wallet) { + wallet.ensureWalletIsReady(this); + return beaconChainStakingTxDelegate.createBeaconChainValidator(createBeaconChainValidator, wallet, options, sync); + } + } + + @Override + public List editValidator(EditBeaconChainValidator editBeaconChainValidator, Wallet wallet, TransactionOption option, boolean sync) throws IOException, NoSuchAlgorithmException { + synchronized (wallet) { + wallet.ensureWalletIsReady(this); + return beaconChainStakingTxDelegate.editBeaconChainValidator(editBeaconChainValidator, wallet, option, sync); + } + } + + @Override + public List delegate(BeaconChainDelegate beaconChainDelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + synchronized (wallet) { + wallet.ensureWalletIsReady(this); + return beaconChainStakingTxDelegate.beaconChainDelegate(beaconChainDelegate, wallet, options, sync); + } + } + + @Override + public List redelegate(BeaconChainRedelegate beaconChainRedelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + synchronized (wallet) { + wallet.ensureWalletIsReady(this); + return beaconChainStakingTxDelegate.beaconChainRedelegate(beaconChainRedelegate, wallet, options, sync); + } + } + + @Override + public List undelegate(BeaconChainUndelegate beaconChainUndelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + synchronized (wallet) { + wallet.ensureWalletIsReady(this); + return beaconChainStakingTxDelegate.beaconChainUndelegate(beaconChainUndelegate, wallet, options, sync); + } + } + + @Override + public BeaconChainValidator getValidator(String validatorAddress) throws IOException { + return beaconChainQueryDelegate.queryBeaconChainValidator(validatorAddress); + } + + @Override + public List getTopValidators(int top) throws IOException { + return beaconChainQueryDelegate.queryBeaconChainTopValidators(top); + } + + @Override + public BeaconChainDelegation getDelegation(String delegatorAddress, String validatorAddress) throws IOException { + return beaconChainQueryDelegate.queryBeaconChainDelegation(delegatorAddress, validatorAddress); + } + + @Override + public List getDelegations(String delegatorAddress) throws IOException { + return beaconChainQueryDelegate.queryBeaconChainDelegations(delegatorAddress); + } + + @Override + public BeaconChainRedelegation getRedelegation(String delegatorAddress, String srcValidatorAddress, String dstValidatorAddress) throws IOException { + return beaconChainQueryDelegate.queryBeaconChainRedelegation(delegatorAddress, srcValidatorAddress, dstValidatorAddress); + } + + @Override + public List getRedelegations(String delegatorAddress) throws IOException { + return beaconChainQueryDelegate.queryBeaconChainRedelegations(delegatorAddress); + } + + @Override + public BeaconChainUnBondingDelegation getUnBondingDelegation(String delegatorAddress, String validatorAddress) throws IOException { + return beaconChainQueryDelegate.queryBeaconChainUnBondingDelegation(delegatorAddress, validatorAddress); + } + + @Override + public List getUnBondingDelegations(String delegatorAddress) throws IOException { + return beaconChainQueryDelegate.queryBeaconChainUnBondingDelegations(delegatorAddress); + } + + @Override + public List getUnBondingDelegationsByValidator(String validatorAddress) throws IOException { + return beaconChainQueryDelegate.queryBeaconChainUnBondingDelegationsByValidator(validatorAddress); + } + + @Override + public List getRedelegationsByValidator(String validatorAddress) throws IOException { + return beaconChainQueryDelegate.queryBeaconChainRedelegationsByValidator(validatorAddress); + } + + @Override + public Pool getPool() throws IOException { + return beaconChainQueryDelegate.queryBeaconChainPool(); + } + + @Override + public long getAllValidatorsCount(boolean jailInvolved) throws IOException { + return beaconChainQueryDelegate.queryAllBeaconChainValidatorsCount(jailInvolved); + } + protected Infos convert(NodeInfos nodeInfos) { Infos infos = new Infos(); diff --git a/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegateBeaconChainStaking.java b/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegateBeaconChainStaking.java new file mode 100644 index 0000000..f3db244 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegateBeaconChainStaking.java @@ -0,0 +1,172 @@ +package com.binance.dex.api.client.impl.node; + +import com.binance.dex.api.client.BinanceDexNodeApi; +import com.binance.dex.api.client.domain.stake.Pool; +import com.binance.dex.api.client.domain.stake.beaconchain.BeaconChainDelegation; +import com.binance.dex.api.client.domain.stake.beaconchain.BeaconChainRedelegation; +import com.binance.dex.api.client.domain.stake.beaconchain.BeaconChainUnBondingDelegation; +import com.binance.dex.api.client.domain.stake.beaconchain.BeaconChainValidator; +import com.binance.dex.api.client.domain.stake.sidechain.*; +import com.binance.dex.api.client.encoding.ByteUtil; +import com.binance.dex.api.client.encoding.EncodeUtils; +import com.binance.dex.api.client.encoding.message.beaconchain.query.BeaconChainRedelegationMessage; +import com.binance.dex.api.client.encoding.message.beaconchain.query.BeaconChainUnBondingDelegationMessage; +import com.binance.dex.api.client.encoding.message.beaconchain.query.PoolMessage; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.encoding.message.sidechain.query.*; +import com.fasterxml.jackson.core.type.TypeReference; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; + +/** + * @author Francis.Liu + **/ +public class NodeQueryDelegateBeaconChainStaking extends NodeQuery { + + private String sideChainId = ""; + + private NodeQueryDelegateSideChainStaking sideChainStakingQuery; + + public NodeQueryDelegateBeaconChainStaking(BinanceDexNodeApi binanceDexNodeApi, String hrp, String valHrp, NodeQueryDelegateSideChainStaking sideChainStakingQuery) { + super(binanceDexNodeApi, hrp, valHrp); + this.sideChainStakingQuery = sideChainStakingQuery; + } + + public BeaconChainValidator queryBeaconChainValidator(String validatorAddress) throws IOException { + QueryValidatorParams params = new QueryValidatorParams(sideChainId, Bech32AddressValue.fromBech32StringWithNewHrp(validatorAddress, valHrp)); + byte[] data = EncodeUtils.toJsonEncodeBytes(params); + byte[] result = queryWithData("\"custom/stake/validator\"", data); + if (!ByteUtil.isEmpty(result)){ + String jsonStr = new String(result); + BechValidator validator = EncodeUtils.getObjectMapper().readValue(jsonStr, new TypeReference(){}); + return BeaconChainValidator.createBySideChainValidator(validator.toSideChainValidator()); + } + return null; + } + + public List queryBeaconChainTopValidators(int top) throws IOException { + List validators = this.sideChainStakingQuery.querySideChainTopValidators(sideChainId, top); + + List beaconChainValidators = new ArrayList<>(); + for (SideChainValidator validator : validators) { + beaconChainValidators.add(BeaconChainValidator.createBySideChainValidator(validator)); + } + return beaconChainValidators; + } + + public BeaconChainDelegation queryBeaconChainDelegation(String delegatorAddress, String validatorAddress) throws IOException { + return BeaconChainDelegation.createBySideChainDelegation(this.sideChainStakingQuery.querySideChainDelegation(sideChainId, delegatorAddress, validatorAddress)); + } + + public List queryBeaconChainDelegations(String delegatorAddress) throws IOException { + List results = new ArrayList<>(); + List delegations = this.sideChainStakingQuery.querySideChainDelegations(sideChainId, delegatorAddress); + for(SideChainDelegation delegation: delegations){ + results.add(BeaconChainDelegation.createBySideChainDelegation(delegation)); + } + return results; + } + + public BeaconChainRedelegation queryBeaconChainRedelegation(String delegatorAddress, String srcValidatorAddress, String dstValidatorAddress) throws IOException { + QueryRedelegationParams params = new QueryRedelegationParams(sideChainId, delegatorAddress, srcValidatorAddress, dstValidatorAddress); + byte[] data = EncodeUtils.toJsonEncodeBytes(params); + byte[] result = queryWithData("\"custom/stake/redelegation\"", data); + + if (!ByteUtil.isEmpty(result)){ + String jsonStr = new String(result); + BeaconChainRedelegationMessage message = EncodeUtils.getObjectMapper().readValue(jsonStr, new TypeReference(){}); + return message.toBeaconChainRedelegation(); + } + return null; + } + + public List queryBeaconChainRedelegations(String delegatorAddress) throws IOException { + QueryDelegatorParams params = new QueryDelegatorParams(); + params.setDelegatorAddr(delegatorAddress); + byte[] data = EncodeUtils.toJsonEncodeBytes(params); + byte[] result = queryWithData("\"custom/stake/delegatorRedelegations\"", data); + List results = new ArrayList<>(); + if (!ByteUtil.isEmpty(result)){ + String jsonStr = new String(result); + List messages = EncodeUtils.getObjectMapper().readValue(jsonStr, new TypeReference>(){}); + for (BeaconChainRedelegationMessage message : messages) { + results.add(message.toBeaconChainRedelegation()); + } + } + return results; + } + + + public BeaconChainUnBondingDelegation queryBeaconChainUnBondingDelegation(String delegatorAddress, String validatorAddress) throws IOException { + QueryBondsParams params = new QueryBondsParams(); + params.setDelegatorAddr(delegatorAddress); + params.setValidatorAddr(validatorAddress); + byte[] data = EncodeUtils.toJsonEncodeBytes(params); + byte[] result = queryWithData("\"custom/stake/unbondingDelegation\"", data); + + if (!ByteUtil.isEmpty(result)){ + String jsonStr = new String(result); + BeaconChainUnBondingDelegationMessage message = EncodeUtils.getObjectMapper().readValue(jsonStr, new TypeReference(){}); + return message.toBeaconChainUnBondingDelegation(); + } + return null; + } + + public List queryBeaconChainUnBondingDelegations(String delegatorAddress) throws IOException { + QueryDelegatorParams params = new QueryDelegatorParams(); + params.setDelegatorAddr(delegatorAddress); + byte[] data = EncodeUtils.toJsonEncodeBytes(params); + byte[] result = queryWithData("\"custom/stake/delegatorUnbondingDelegations\"", data); + List results = new ArrayList<>(); + if (!ByteUtil.isEmpty(result)){ + String jsonStr = new String(result); + List messages = EncodeUtils.getObjectMapper().readValue(jsonStr, new TypeReference>(){}); + for (BeaconChainUnBondingDelegationMessage message : messages) { + results.add(message.toBeaconChainUnBondingDelegation()); + } + } + return results; + } + + public List queryBeaconChainUnBondingDelegationsByValidator(String validatorAddress) throws IOException { + List beaconChainUnBondingDelegations = new ArrayList<>(); + List unBondingDelegations = this.sideChainStakingQuery.querySideChainUnBondingDelegationsByValidator(sideChainId, validatorAddress); + + for (UnBondingDelegation unBondingDelegation : unBondingDelegations) { + beaconChainUnBondingDelegations.add(BeaconChainUnBondingDelegation.createByUnBondingDelegation(unBondingDelegation)); + } + + return beaconChainUnBondingDelegations; + } + + public List queryBeaconChainRedelegationsByValidator(String validatorAddress) throws IOException { + List beaconChainRedelegations = new ArrayList<>(); + List sideChainRedelegations = this.sideChainStakingQuery.querySideChainRedelegationsByValidator(sideChainId, validatorAddress); + + for (SideChainRedelegation sideChainRedelegation : sideChainRedelegations) { + beaconChainRedelegations.add(BeaconChainRedelegation.createBySideChainRedelegation(sideChainRedelegation)); + } + + return beaconChainRedelegations; + } + + public Pool queryBeaconChainPool() throws IOException { + BaseQueryParams params = new BaseQueryParams(); + byte[] data = EncodeUtils.toJsonEncodeBytes(params); + byte[] result = queryWithData("\"custom/stake/pool\"", data); + + if (!ByteUtil.isEmpty(result)){ + String jsonStr = new String(result); + PoolMessage message = EncodeUtils.getObjectMapper().readValue(jsonStr, new TypeReference(){}); + return message.toPool(); + } + return null; + } + + public long queryAllBeaconChainValidatorsCount(boolean jailInvolved) throws IOException { + return this.sideChainStakingQuery.queryAllSideChainValidatorsCount(sideChainId, jailInvolved); + } + +} diff --git a/src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegateBeaconChainStaking.java b/src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegateBeaconChainStaking.java new file mode 100644 index 0000000..a4089fb --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/impl/node/NodeTxDelegateBeaconChainStaking.java @@ -0,0 +1,172 @@ +package com.binance.dex.api.client.impl.node; + +import com.binance.dex.api.client.BinanceDexNodeApi; +import com.binance.dex.api.client.Wallet; +import com.binance.dex.api.client.domain.TransactionMetadata; +import com.binance.dex.api.client.domain.broadcast.TransactionOption; +import com.binance.dex.api.client.domain.stake.Commission; +import com.binance.dex.api.client.domain.stake.Description; +import com.binance.dex.api.client.domain.stake.beaconchain.*; +import com.binance.dex.api.client.encoding.message.Token; +import com.binance.dex.api.client.encoding.message.beaconchain.transaction.*; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.encoding.message.common.CoinValueStr; +import com.binance.dex.api.client.encoding.message.common.Dec; +import com.binance.dex.api.client.encoding.message.sidechain.value.CommissionMsgValue; +import com.binance.dex.api.client.encoding.message.sidechain.value.DescriptionValue; +import com.google.common.annotations.VisibleForTesting; +import org.apache.commons.lang3.StringUtils; +import org.bouncycastle.util.encoders.Hex; + +import java.io.IOException; +import java.security.NoSuchAlgorithmException; +import java.util.List; + +/** + * @author Francis.Liu + **/ +public class NodeTxDelegateBeaconChainStaking extends NodeTx { + + public NodeTxDelegateBeaconChainStaking(BinanceDexNodeApi binanceDexNodeApi, String hrp, String valHrp) { + super(binanceDexNodeApi, hrp, valHrp); + } + + public List createBeaconChainValidator(CreateBeaconChainValidator createBeaconChainValidator, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + CreateBeaconChainValidatorMessage message = convert(createBeaconChainValidator); + if (StringUtils.isEmpty(createBeaconChainValidator.getValidatorAddr())) { + message.setValidatorOperatorAddr(Bech32AddressValue.fromBech32StringWithNewHrp(wallet.getAddress(), valHrp)); + }else{ + message.setValidatorOperatorAddr(Bech32AddressValue.fromBech32StringWithNewHrp(createBeaconChainValidator.getValidatorAddr(), valHrp)); + } + return broadcast(message, wallet, options, sync); + } + + public List editBeaconChainValidator(EditBeaconChainValidator editBeaconChainValidator, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + EditBeaconChainValidatorMessage message = convert(editBeaconChainValidator); + if (StringUtils.isEmpty(editBeaconChainValidator.getValidatorAddress())) { + message.setValidatorOperatorAddress(Bech32AddressValue.fromBech32StringWithNewHrp(wallet.getAddress(), valHrp)); + }else{ + message.setValidatorOperatorAddress(Bech32AddressValue.fromBech32StringWithNewHrp(editBeaconChainValidator.getValidatorAddress(), valHrp)); + } + return broadcast(message, wallet, options, sync); + } + + public List beaconChainDelegate(BeaconChainDelegate beaconChainDelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + BeaconChainDelegateMessage message = convert(beaconChainDelegate); + return broadcast(message, wallet, options, sync); + } + + public List beaconChainRedelegate(BeaconChainRedelegate beaconChainRedelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + BeaconChainRedelegateMessage message = convert(beaconChainRedelegate); + return broadcast(message, wallet, options, sync); + } + + public List beaconChainUndelegate(BeaconChainUndelegate beaconChainUndelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException { + BeaconChainUndelegateMessage message = convert(beaconChainUndelegate); + return broadcast(message, wallet, options, sync); + } + + @VisibleForTesting + CreateBeaconChainValidatorMessage convert(CreateBeaconChainValidator createBeaconChainValidator){ + CreateBeaconChainValidatorMessage message = new CreateBeaconChainValidatorMessage(); + + if (createBeaconChainValidator.getDescription() != null){ + message.setDescription(convert(createBeaconChainValidator.getDescription())); + } + if (createBeaconChainValidator.getCommission() != null){ + message.setCommission(convert(createBeaconChainValidator.getCommission())); + } + + message.setDelegatorAddr(Bech32AddressValue.fromBech32String(createBeaconChainValidator.getDelegatorAddr())); + + if (createBeaconChainValidator.getDelegation() != null){ + message.setDelegation(convert(createBeaconChainValidator.getDelegation())); + } + + message.setPubKey(createBeaconChainValidator.getPubKey()); + return message; + } + + @VisibleForTesting + EditBeaconChainValidatorMessage convert(EditBeaconChainValidator editBeaconChainValidator){ + EditBeaconChainValidatorMessage message = new EditBeaconChainValidatorMessage(); + + if (editBeaconChainValidator.getDescription() != null){ + message.setDescription(convert(editBeaconChainValidator.getDescription())); + } + + message.setCommissionRate(Dec.newInstance(editBeaconChainValidator.getCommissionRate())); + if (editBeaconChainValidator.getPubKey() != null){ + message.setPubKey(editBeaconChainValidator.getPubKey()); + } + + return message; + } + + private byte[] decodeHexAddress(String address){ + String addr = address; + if (addr.startsWith("0x")){ + addr = address.substring(2); + } + return Hex.decode(addr); + } + + private DescriptionValue convert(Description description){ + DescriptionValue value = new DescriptionValue(); + value.setMoniker(description.getMoniker()); + value.setDetails(description.getDetails()); + value.setIdentity(description.getIdentity()); + value.setWebsite(description.getWebsite()); + return value; + } + + private CommissionMsgValue convert(Commission commission){ + CommissionMsgValue value = new CommissionMsgValue(); + value.setRate(Dec.newInstance(commission.getRate())); + value.setMaxRate(Dec.newInstance(commission.getMaxRate())); + value.setMaxChangeRate(Dec.newInstance(commission.getMaxChangeRate())); + return value; + } + + private CoinValueStr convert(Token token){ + CoinValueStr value = new CoinValueStr(); + value.setDenom(token.getDenom()); + value.setAmount(token.getAmount()); + return value; + } + + private BeaconChainDelegateMessage convert(BeaconChainDelegate beaconChainDelegate){ + BeaconChainDelegateMessage message = new BeaconChainDelegateMessage(); + message.setDelegatorAddress(Bech32AddressValue.fromBech32String(beaconChainDelegate.getDelegatorAddress())); + message.setValidatorAddress(Bech32AddressValue.fromBech32StringWithNewHrp(beaconChainDelegate.getValidatorAddress(), valHrp)); + + if (beaconChainDelegate.getDelegation() != null) { + message.setDelegation(convert(beaconChainDelegate.getDelegation())); + } + + return message; + } + + private BeaconChainRedelegateMessage convert(BeaconChainRedelegate redelegate){ + BeaconChainRedelegateMessage message = new BeaconChainRedelegateMessage(); + message.setDelegatorAddress(Bech32AddressValue.fromBech32String(redelegate.getDelegatorAddress())); + message.setSrcValidatorAddress(Bech32AddressValue.fromBech32StringWithNewHrp(redelegate.getSrcValidatorAddress(), valHrp)); + message.setDstValidatorAddress(Bech32AddressValue.fromBech32StringWithNewHrp(redelegate.getDstValidatorAddress(), valHrp)); + if (redelegate.getAmount() != null) { + message.setAmount(convert(redelegate.getAmount())); + } + return message; + } + + private BeaconChainUndelegateMessage convert(BeaconChainUndelegate unBond){ + BeaconChainUndelegateMessage message = new BeaconChainUndelegateMessage(); + message.setDelegatorAddress(Bech32AddressValue.fromBech32String(unBond.getDelegatorAddress())); + message.setValidatorAddress(Bech32AddressValue.fromBech32StringWithNewHrp(unBond.getValidatorAddress(), valHrp)); + if (unBond.getAmount() != null) { + message.setAmount(convert(unBond.getAmount())); + } + return message; + } + + +} diff --git a/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java b/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java index 8d91392..80eb68a 100644 --- a/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java +++ b/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java @@ -8,8 +8,10 @@ import com.binance.dex.api.client.domain.stake.Description; import com.binance.dex.api.client.domain.stake.sidechain.*; import com.binance.dex.api.client.encoding.amino.Amino; +import com.binance.dex.api.client.encoding.amino.types.PubKeyEd25519; import com.binance.dex.api.client.encoding.message.MessageType; import com.binance.dex.api.client.encoding.message.Token; +import com.binance.dex.api.client.encoding.message.beaconchain.transaction.EditBeaconChainValidatorMessage; import com.binance.dex.api.client.encoding.message.bridge.*; import com.binance.dex.api.client.encoding.message.common.*; import com.binance.dex.api.client.encoding.message.sidechain.transaction.*; @@ -51,6 +53,16 @@ public void testClaim() throws IOException { Assert.assertNotNull(transaction.getRealTx()); } + public static byte[] hexStringToByteArray(String s) { + int len = s.length(); + byte[] data = new byte[len / 2]; + for (int i = 0; i < len; i += 2) { + data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4) + + Character.digit(s.charAt(i+1), 16)); + } + return data; + } + @Test public void testTransferOut() throws IOException { TransferOutMsgMessage message = new TransferOutMsgMessage(); diff --git a/src/test/java/com/binance/dex/api/client/examples/BeaconChainStakingNodeExample.java b/src/test/java/com/binance/dex/api/client/examples/BeaconChainStakingNodeExample.java new file mode 100644 index 0000000..136c787 --- /dev/null +++ b/src/test/java/com/binance/dex/api/client/examples/BeaconChainStakingNodeExample.java @@ -0,0 +1,450 @@ +package com.binance.dex.api.client.examples; + +import com.binance.dex.api.client.BinanceDexApiClientFactory; +import com.binance.dex.api.client.BinanceDexApiNodeClient; +import com.binance.dex.api.client.BinanceDexEnvironment; +import com.binance.dex.api.client.Wallet; +import com.binance.dex.api.client.domain.Infos; +import com.binance.dex.api.client.domain.StakeValidator; +import com.binance.dex.api.client.domain.TransactionMetadata; +import com.binance.dex.api.client.domain.broadcast.TransactionOption; +import com.binance.dex.api.client.domain.broadcast.Transfer; +import com.binance.dex.api.client.domain.stake.Commission; +import com.binance.dex.api.client.domain.stake.Description; +import com.binance.dex.api.client.domain.stake.Pool; +import com.binance.dex.api.client.domain.stake.beaconchain.*; +import com.binance.dex.api.client.domain.stake.sidechain.CreateSideChainValidator; +import com.binance.dex.api.client.domain.stake.sidechain.EditSideChainValidator; +import com.binance.dex.api.client.encoding.Crypto; +import com.binance.dex.api.client.encoding.message.Token; +import com.binance.dex.api.client.encoding.message.sidechain.SideChainIds; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.io.IOException; +import java.security.NoSuchAlgorithmException; +import java.util.ArrayList; +import java.util.List; + +/** + * @author Francis.Liu + **/ +public class BeaconChainStakingNodeExample { + + private Logger logger = LoggerFactory.getLogger(BeaconChainStakingNodeExample.class); + + private BinanceDexApiNodeClient nodeClient = null; + + private BinanceDexEnvironment env; + private Wallet wallet; + + private List getMnemonicCodeWords(){ + String mnemonicCodeWordStr = "bottom quick strong ranch section decide pepper broken oven demand coin run jacket curious business achieve mule bamboo remain vote kid rigid bench rubber"; + List mnemonicCodeWords = new ArrayList(); + String[] mnemonicCodeWordStrs = mnemonicCodeWordStr.split(" "); + for (String mnemonicCodeWord : mnemonicCodeWordStrs) { + mnemonicCodeWords.add(mnemonicCodeWord); + } + return mnemonicCodeWords; + } + + @Before + public void setup() { + env = BinanceDexEnvironment.LOCAL_NET; + + nodeClient = BinanceDexApiClientFactory.newInstance().newNodeRpcClient(env.getNodeUrl() + ,env.getHrp(), env.getValHrp()); + try { + wallet = Wallet.createWalletFromMnemonicCode(this.getMnemonicCodeWords(), env); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + +// @Test +// public void testCreateSideChainValidator() throws IOException, NoSuchAlgorithmException { +// CreateSideChainValidator createSideChainValidator = new CreateSideChainValidator(); +// +// //create and set description +// Description validatorDescription = new Description(); +// validatorDescription.setMoniker("rose-moniker"); +// validatorDescription.setIdentity("rose id"); +// validatorDescription.setWebsite("https://www.rose.com"); +// validatorDescription.setDetails("This is rose validator"); +// +// createSideChainValidator.setDescription(validatorDescription); +// +// //create and set commission +// Commission commission = new Commission(); +// commission.setRate(5L); +// commission.setMaxRate(1000L); +// commission.setMaxChangeRate(10L); +// +// createSideChainValidator.setCommission(commission); +// +// //set delegator address, here use self address +// createSideChainValidator.setDelegatorAddr(wallet.getAddress()); +// +// //set delegation token, here use 1000000 BNB +// Token delegationToken = new Token(); +// delegationToken.setDenom("BNB"); +// delegationToken.setAmount(2000000000000L); +// +// createSideChainValidator.setDelegation(delegationToken); +// //set side-chain id +// createSideChainValidator.setSideChainId("bsc"); +// +// //set side-chain validator cons address +// createSideChainValidator.setSideConsAddr("0x9fB29AAc15b9A4B7F17c3385939b007540f4d791"); +// +// //set side-chain validator fee address +// createSideChainValidator.setSideFeeAddr("0xd1B22dCC24C55f4d728E7aaA5c9b5a22e1512C08"); +// +// TransactionOption options = new TransactionOption("", 0, null); +// +// List transactionMetadatas = nodeClient.createSideChainValidator(createSideChainValidator, wallet, options, true); +// Assert.assertEquals(1, transactionMetadatas.size()); +// } +// +// @Test +// public void testEditSideChainValidator() throws IOException, NoSuchAlgorithmException { +// EditSideChainValidator editSideChainValidator = new EditSideChainValidator(); +// +// //set new description if needed +// Description description = new Description(); +// description.setMoniker("new Moniker"); +// editSideChainValidator.setDescription(description); +// +// //set new rate if needed +//// editSideChainValidator.setCommissionRate(1L); +// +// //set new fee address if needed +// editSideChainValidator.setSideFeeAddr("0xd1B22dCC24C55f4d728E7aaA5c9b5a22e1512C08"); +// +// editSideChainValidator.setSideChainId("bsc"); +// +// List transactionMetadatas = nodeClient.editSideChainValidator(editSideChainValidator, wallet, createTransactionOptionForTest(), true); +// Assert.assertEquals(1, transactionMetadatas.size()); +// } + + + private int pubKeyIndex = 0; + + private String genPubKey() throws IOException { + ArrayList pubKeys = new ArrayList<>(); + pubKeys.add("bcap1zcjduepq2equ54uaf02j98y9k5ksq2aau9ajns22gfkwgv8ut6ngx5cyteaq6jh5kf"); + pubKeys.add("bcap1zcjduepq6hpw8zdrqdj2cd07p07pktp2lym7fkm9hn5dkwqczm3rplcupgqsq0w7ev"); + pubKeys.add("bcap1zcjduepqcr6zgwf95lmxyj0tq6yh4dz4p3r0dkl4m0zrwj9jzgr2pmmct3qqtepuh3"); + pubKeys.add("bcap1zcjduepqq8600wvagq3n6j3ldk223tzkw433jjwywj4wfjevx74hvtztp8tsndacz7"); + pubKeys.add("bcap1zcjduepqhrmhu3a7f9z4v3a50z3pa39p872hgqud2t3quh2zsvx3fj0plu3qmar9mh"); + String pubKey = pubKeys.get(pubKeyIndex); + pubKeyIndex = pubKeyIndex + 1; + return pubKey; + } + + private Wallet genWalletWithBNB(Wallet tokenFrom) throws IOException, NoSuchAlgorithmException { + Wallet newWallet = Wallet.createRandomWallet(env); + + String symbol = "BNB"; + Transfer transfer = new Transfer(); + transfer.setCoin(symbol); + transfer.setFromAddress(tokenFrom.getAddress()); + transfer.setToAddress(newWallet.getAddress()); + transfer.setAmount("150"); + + TransactionOption options = new TransactionOption("test", 1, null); + List resp = nodeClient.transfer(transfer, tokenFrom, options, true); + return newWallet; + } + + + @Test + public void testStaking() throws IOException, NoSuchAlgorithmException { + logger.info("-------------------- begin staking test -------------------"); + Wallet bob = Wallet.createWalletFromMnemonicCode(this.getMnemonicCodeWords(), env); + logger.info(String.format("chainId = %s \n", bob.getChainId())); + + Infos infos = nodeClient.getNodeInfo(); + logger.info(String.format("infos = %s\n", infos)); + logger.info(String.format("bob address %s \n", bob.getAddress())); + + // create a random account + Wallet validator0 = this.genWalletWithBNB(bob); + logger.info(String.format("validator0 address %s \n", validator0.getAddress())); + + // validators + List validators = nodeClient.getStakeValidator(); + logger.info(String.format("validators %s \n", validators)); + logger.info(String.format("validators length %s \n", validators.size())); + Assert.assertTrue("validators len should be >= 1", validators.size() >= 1); + + // query validators count (including jailed) + long validatorCount = nodeClient.getAllValidatorsCount(true); + logger.info(String.format("validators count: %d \n", validatorCount)); + + // query validators count (excluding jailed) + long validatorCountWithoutJail = nodeClient.getAllValidatorsCount(false); + logger.info(String.format("validators count: %d \n", validatorCountWithoutJail)); + + Assert.assertEquals("there is no jailed validators yet", validatorCount, validatorCountWithoutJail); + + // create validator + String consensusPubKey = genPubKey(); + this.createBeaconChainValidator(validator0, consensusPubKey); + long validatorCountAfterCreate = nodeClient.getAllValidatorsCount(true); + logger.info(String.format("validators count: %d \n", validatorCountAfterCreate)); + Assert.assertEquals("validators count should be +1", validatorCountAfterCreate, validatorCount + 1); + + // query top validators + int topValidatorNum = 3; + List topValidators = nodeClient.getTopValidators(topValidatorNum); + logger.info(String.format("top validators %s \n", topValidators)); + Assert.assertTrue("top validators should be 1", topValidators.size() == topValidatorNum); + BeaconChainValidator topValidator = topValidators.get(0); + + // query validator + String validator0ValAddr = Crypto.getAddressFromPrivateKey(validator0.getPrivateKey(), env.getValHrp()); + logger.info(String.format("validator addr %s \n", validator0ValAddr)); + BeaconChainValidator validator = nodeClient.getValidator(validator0ValAddr); + logger.info(String.format("query validator: %s \n", validator)); + Assert.assertNotNull("validator should not be nil", validator); + Assert.assertEquals("validator address should be equal", validator.getFeeAddr(), validator0.getAddress()); + Assert.assertEquals("validator tokens should be 123e8", validator.getTokens(), 12300000000L); + Assert.assertEquals("validator description should be equal", validator.getDescription().getMoniker(), "node1"); + Assert.assertEquals("validator rate should be equal", validator.getCommission().getRate(), 1); + Assert.assertEquals("validator consensusPubKey should be equal", new String(validator.getConsPubKey()), consensusPubKey); + + // edit validator todo + String consensusPubKey2 = genPubKey(); + this.editBeaconChainValidator(validator0, consensusPubKey2); + + // check edit validator change + validator = nodeClient.getValidator(validator0.getAddress()); + logger.info(String.format("query validator: %s \n", validator)); + Assert.assertNotNull("validator should not be nil", validator); + Assert.assertEquals("validator address should be equal", validator.getFeeAddr(), validator0.getAddress()); + Assert.assertEquals("validator tokens should be 123e8", validator.getTokens(), 12300000000L); + Assert.assertEquals("validator description should be equal", validator.getDescription().getMoniker(), "node1_v2"); + Assert.assertEquals("validator rate should be equal", validator.getCommission().getRate(), 1); + Assert.assertEquals("validator consensusPubKey should be equal", new String(validator.getConsPubKey()), consensusPubKey2); + long tokenBeforeDelegate = validator.getTokens(); + + // delegate + Wallet delegator = this.genWalletWithBNB(bob); + String delegatorValAddr = Crypto.getAddressFromPrivateKey(delegator.getPrivateKey(), env.getValHrp()); + long delegateAmount = 500000000L; + this.beaconChainDelegate(delegator, validator0.getAddress(), delegateAmount); + + // check delegation + validator = nodeClient.getValidator(validator0.getAddress()); + logger.info(String.format("query validator: %s \n", validator)); + long tokenAfterDelegate = validator.getTokens(); + Assert.assertEquals("delegate tokens should be equal", tokenAfterDelegate - tokenBeforeDelegate, delegateAmount); + + // query delegation + BeaconChainDelegation delegationQuery = nodeClient.getDelegation(delegator.getAddress(), validator0ValAddr); + logger.info(String.format("query delegation: %s \n", delegationQuery)); + Assert.assertEquals("delegation shares should be equal", delegationQuery.getDelegation().getShares(), delegateAmount); + + // query delegations + List delegations = nodeClient.getDelegations(delegator.getAddress()); + logger.info(String.format("query delegations: %s \n", delegations)); + + // check redelegate preparation + String topValAddr = topValidator.getOperatorAddr(); + BeaconChainValidator topValidatorBeforeRedelegate = nodeClient.getValidator(topValAddr); + logger.info(String.format("top validator before redelegate: %s \n", topValidatorBeforeRedelegate)); + + // redelegate from validator0 to top validator, should success immediately + long redelegateAmount = 200000000L; + this.beaconChainRedelegate(delegator, validator0.getAddress(), topValAddr, redelegateAmount); + BeaconChainValidator topValidatorAfterRedelegate = nodeClient.getValidator(topValAddr); + logger.info(String.format("top validator after redelegate: %s \n", topValidatorAfterRedelegate)); + Assert.assertEquals("redelegate tokens should be equal", topValidatorAfterRedelegate.getTokens() - topValidatorBeforeRedelegate.getTokens(), redelegateAmount); + + // undelegate + this.beaconChainUndelegate(delegator, topValAddr, redelegateAmount); + BeaconChainValidator topValidatorAfterUndelegate = nodeClient.getValidator(topValAddr); + logger.info(String.format("top validator after undelegate: %s \n", topValidatorAfterUndelegate)); + Assert.assertEquals("check undelegation token change", topValidatorAfterUndelegate.getTokens(), topValidatorBeforeRedelegate.getTokens()); + + // query pool + Pool pool = nodeClient.getPool(); + logger.info(String.format("pool: %s \n", pool)); + + // query unbonding delegation + BeaconChainUnBondingDelegation unbondingDelegation = nodeClient.getUnBondingDelegation(delegator.getAddress(), topValAddr); + logger.info(String.format("query unbonding delegation: %s \n", unbondingDelegation)); + + // query unbonding delegations + List unbondingDelegations = nodeClient.getUnBondingDelegations(delegator.getAddress()); + logger.info(String.format("query unbonding delegations: %s \n", unbondingDelegations)); + + // query unbonding delegations by validator + List unbondingDelegationsByValidator = nodeClient.getUnBondingDelegationsByValidator(topValAddr); + logger.info(String.format("query unbonding delegations by validator: %s \n", unbondingDelegationsByValidator)); + + // delegate to top validator and then redelegate + Wallet delegator0 = genWalletWithBNB(bob); + this.beaconChainDelegate(delegator0, topValAddr, delegateAmount); + logger.info(String.format("dest validator: %s \n", topValAddr)); + logger.info(String.format("validator0 val address: %s \n", validator0.getAddress())); + logger.info(String.format("delegator address: %s \n", delegator0.getAddress())); + + this.beaconChainRedelegate(delegator0, topValAddr, validator0.getAddress(), delegateAmount); + + // query redelegation + BeaconChainRedelegation redelegation = nodeClient.getRedelegation(delegator0.getAddress(), topValAddr, validator0ValAddr); + logger.info(String.format("query redelegation: %s \n", redelegation)); + Assert.assertNotNull("redelegation should not be nil", redelegation); + + // query redelegations + List redelegations = nodeClient.getRedelegations(delegator0.getAddress()); + logger.info(String.format("query redelegations: %s \n", redelegations)); + Assert.assertTrue("redelegations should not be empty", redelegations.size() > 0); + + // query redelegations by source validator + List redelegationsByValidator = nodeClient.getRedelegationsByValidator(topValAddr); + logger.info(String.format("query redelegations by validator: %s \n", redelegationsByValidator)); + Assert.assertTrue("redelegations by validator should not be empty", redelegationsByValidator.size() > 0); + + + logger.info("-------------------- end staking test -------------------"); + } + + + + + public void createBeaconChainValidator(Wallet wallet, String pubKey) throws IOException, NoSuchAlgorithmException { + CreateBeaconChainValidator createBeaconChainValidator = new CreateBeaconChainValidator(); + + //create and set description + Description validatorDescription = new Description(); + validatorDescription.setMoniker("node1"); + validatorDescription.setIdentity("rose id"); + validatorDescription.setWebsite("https://www.rose.com"); + validatorDescription.setDetails("This is rose validator"); + + createBeaconChainValidator.setDescription(validatorDescription); + + //create and set commission + Commission commission = new Commission(); + commission.setRate(1); + commission.setMaxRate(1); + commission.setMaxChangeRate(1); + + createBeaconChainValidator.setCommission(commission); + + //set delegator address, here use self address + createBeaconChainValidator.setDelegatorAddr(wallet.getAddress()); + + //set delegation token, here use 1000000 BNB + Token delegationToken = new Token(); + delegationToken.setDenom("BNB"); + delegationToken.setAmount(12300000000L); + createBeaconChainValidator.setDelegation(delegationToken); + + + createBeaconChainValidator.setPubKey(pubKey); + + TransactionOption options = new TransactionOption("", 0, null); + + List transactionMetadatas = nodeClient.createValidator(createBeaconChainValidator, wallet, options, true); + logger.info(String.format("create validator res %s \n", transactionMetadatas)); + Assert.assertEquals(1, transactionMetadatas.size()); + Assert.assertEquals(0, transactionMetadatas.get(0).getCode()); + } + + + public void editBeaconChainValidator(Wallet wallet, String pubKey) throws IOException, NoSuchAlgorithmException { + EditBeaconChainValidator editBeaconChainValidator = new EditBeaconChainValidator(); + + //set new description if needed + Description validatorDescription = new Description(); + validatorDescription.setMoniker("node1_v2"); + + editBeaconChainValidator.setDescription(validatorDescription); + +// editBeaconChainValidator.setCommissionRate(1L); + + editBeaconChainValidator.setPubKey(pubKey); + + List transactionMetadatas = nodeClient.editValidator(editBeaconChainValidator, wallet, createTransactionOptionForTest(), true); + logger.info(String.format("edit validator res %s \n", transactionMetadatas)); + Assert.assertEquals(1, transactionMetadatas.size()); + Assert.assertEquals(0, transactionMetadatas.get(0).getCode()); + } + + public void beaconChainDelegate(Wallet wallet, String validatorAddress, Long amount) throws IOException, NoSuchAlgorithmException { + BeaconChainDelegate beaconChainDelegate = new BeaconChainDelegate(); + + //set delegate token + Token delegation = new Token("BNB", amount); + beaconChainDelegate.setDelegation(delegation); + + //set delegator address, here is self + beaconChainDelegate.setDelegatorAddress(wallet.getAddress()); + + //set validator address + beaconChainDelegate.setValidatorAddress(validatorAddress); + + + List transactionMetadatas = nodeClient.delegate(beaconChainDelegate, wallet, createTransactionOptionForTest(), true); + logger.info(String.format("delegate validator res %s \n", transactionMetadatas)); + Assert.assertEquals(1, transactionMetadatas.size()); + Assert.assertEquals(0, transactionMetadatas.get(0).getCode()); + } + + public void beaconChainRedelegate(Wallet wallet, String srcValidatorAddress, String dstValidatorAddress, Long amount) throws IOException, NoSuchAlgorithmException { + BeaconChainRedelegate redelegate = new BeaconChainRedelegate(); + + //set redelegate amount + redelegate.setAmount(new Token("bnb".toUpperCase(), amount)); + + //set delegator address + redelegate.setDelegatorAddress(wallet.getAddress()); + + //set source validator address + redelegate.setSrcValidatorAddress(srcValidatorAddress); + + //set destination validator address + redelegate.setDstValidatorAddress(dstValidatorAddress); + + List transactionMetadatas = nodeClient.redelegate(redelegate, wallet, createTransactionOptionForTest(), true); + logger.info(String.format("redelegate res %s \n", transactionMetadatas)); + Assert.assertEquals(1, transactionMetadatas.size()); + Assert.assertEquals(0, transactionMetadatas.get(0).getCode()); + } + + public void beaconChainUndelegate(Wallet wallet, String validatorAddress, Long amount) throws IOException, NoSuchAlgorithmException { + BeaconChainUndelegate beaconChainUndelegate = new BeaconChainUndelegate(); + + //set unbond amount + beaconChainUndelegate.setAmount(new Token("BNB", amount)); + + //set delegator address + beaconChainUndelegate.setDelegatorAddress(wallet.getAddress()); + + //set validator address + beaconChainUndelegate.setValidatorAddress(validatorAddress); + + + List transactionMetadatas = nodeClient.undelegate(beaconChainUndelegate, wallet, createTransactionOptionForTest(), true); + logger.info(String.format("undelegate res %s \n", transactionMetadatas)); + Assert.assertEquals(1, transactionMetadatas.size()); + Assert.assertEquals(0, transactionMetadatas.get(0).getCode()); + } + + /** + * Create a transaction option for test + * + * @return TransactionOption + * */ + private TransactionOption createTransactionOptionForTest(){ + return new TransactionOption("", 0, null); + } + +} From 2615455b1436e2c730989ae75e47100f76ca60f4 Mon Sep 17 00:00:00 2001 From: "francis.l" Date: Tue, 27 Sep 2022 10:35:39 +0800 Subject: [PATCH 41/52] [feat][staking] init --- .../BeaconChainStakingNodeExample.java | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/test/java/com/binance/dex/api/client/examples/BeaconChainStakingNodeExample.java b/src/test/java/com/binance/dex/api/client/examples/BeaconChainStakingNodeExample.java index 136c787..2c9ec89 100644 --- a/src/test/java/com/binance/dex/api/client/examples/BeaconChainStakingNodeExample.java +++ b/src/test/java/com/binance/dex/api/client/examples/BeaconChainStakingNodeExample.java @@ -219,17 +219,17 @@ public void testStaking() throws IOException, NoSuchAlgorithmException { // edit validator todo String consensusPubKey2 = genPubKey(); - this.editBeaconChainValidator(validator0, consensusPubKey2); +// this.editBeaconChainValidator(validator0, consensusPubKey2); // check edit validator change - validator = nodeClient.getValidator(validator0.getAddress()); - logger.info(String.format("query validator: %s \n", validator)); - Assert.assertNotNull("validator should not be nil", validator); - Assert.assertEquals("validator address should be equal", validator.getFeeAddr(), validator0.getAddress()); - Assert.assertEquals("validator tokens should be 123e8", validator.getTokens(), 12300000000L); - Assert.assertEquals("validator description should be equal", validator.getDescription().getMoniker(), "node1_v2"); - Assert.assertEquals("validator rate should be equal", validator.getCommission().getRate(), 1); - Assert.assertEquals("validator consensusPubKey should be equal", new String(validator.getConsPubKey()), consensusPubKey2); +// validator = nodeClient.getValidator(validator0.getAddress()); +// logger.info(String.format("query validator: %s \n", validator)); +// Assert.assertNotNull("validator should not be nil", validator); +// Assert.assertEquals("validator address should be equal", validator.getFeeAddr(), validator0.getAddress()); +// Assert.assertEquals("validator tokens should be 123e8", validator.getTokens(), 12300000000L); +// Assert.assertEquals("validator description should be equal", validator.getDescription().getMoniker(), "node1_v2"); +// Assert.assertEquals("validator rate should be equal", validator.getCommission().getRate(), 1); +// Assert.assertEquals("validator consensusPubKey should be equal", new String(validator.getConsPubKey()), consensusPubKey2); long tokenBeforeDelegate = validator.getTokens(); // delegate From 4eb0a7c9e5ae60cedab8c0488ee7792560d92600 Mon Sep 17 00:00:00 2001 From: "francis.l" Date: Thu, 29 Sep 2022 11:07:14 +0800 Subject: [PATCH 42/52] [feat][staking] refactor common class name between beacon and side chain --- .../api/client/BinanceDexApiNodeClient.java | 39 ++-- ...deChainDelegation.java => Delegation.java} | 14 +- .../Delegation.java => DelegationItem.java} | 6 +- ...ainRedelegation.java => Redelegation.java} | 19 +- .../{sidechain => }/UnBondingDelegation.java | 15 +- ...SideChainValidator.java => Validator.java} | 7 +- .../beaconchain/BeaconChainDelegation.java | 46 ---- .../beaconchain/BeaconChainRedelegation.java | 167 -------------- .../BeaconChainUnBondingDelegation.java | 117 ---------- .../beaconchain/BeaconChainValidator.java | 207 ------------------ .../query/BeaconChainRedelegationMessage.java | 7 +- ...BeaconChainUnBondingDelegationMessage.java | 9 +- .../sidechain/query/BechValidator.java | 7 +- .../impl/BinanceDexApiNodeClientImpl.java | 39 ++-- .../NodeQueryDelegateBeaconChainStaking.java | 76 +++---- .../NodeQueryDelegateSideChainStaking.java | 49 ++--- .../BeaconChainStakingNodeExample.java | 32 ++- .../examples/SideChainStakingNodeExample.java | 18 +- 18 files changed, 171 insertions(+), 703 deletions(-) rename src/main/java/com/binance/dex/api/client/domain/stake/{sidechain/SideChainDelegation.java => Delegation.java} (56%) rename src/main/java/com/binance/dex/api/client/domain/stake/{sidechain/Delegation.java => DelegationItem.java} (86%) rename src/main/java/com/binance/dex/api/client/domain/stake/{sidechain/SideChainRedelegation.java => Redelegation.java} (80%) rename src/main/java/com/binance/dex/api/client/domain/stake/{sidechain => }/UnBondingDelegation.java (78%) rename src/main/java/com/binance/dex/api/client/domain/stake/{sidechain/SideChainValidator.java => Validator.java} (97%) delete mode 100644 src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainDelegation.java delete mode 100644 src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainRedelegation.java delete mode 100644 src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainUnBondingDelegation.java delete mode 100644 src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainValidator.java diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java b/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java index ce20b88..bab0fea 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexApiNodeClient.java @@ -1,7 +1,6 @@ package com.binance.dex.api.client; import com.binance.dex.api.client.domain.*; -import com.binance.dex.api.client.domain.bridge.TransferIn; import com.binance.dex.api.client.domain.broadcast.*; import com.binance.dex.api.client.domain.broadcast.Transaction; import com.binance.dex.api.client.domain.oracle.Prophecy; @@ -11,6 +10,10 @@ import com.binance.dex.api.client.domain.request.TransactionsRequest; import com.binance.dex.api.client.domain.stake.Pool; import com.binance.dex.api.client.domain.stake.beaconchain.*; +import com.binance.dex.api.client.domain.stake.Delegation; +import com.binance.dex.api.client.domain.stake.Redelegation; +import com.binance.dex.api.client.domain.stake.UnBondingDelegation; +import com.binance.dex.api.client.domain.stake.Validator; import com.binance.dex.api.client.domain.stake.sidechain.*; import javax.annotation.Nullable; @@ -247,25 +250,25 @@ default List unfreeze(TokenUnfreeze unfreeze, Wallet wallet List undelegate(BeaconChainUndelegate beaconChainUndelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; - BeaconChainValidator getValidator(String validatorAddress) throws IOException; + Validator getValidator(String validatorAddress) throws IOException; - List getTopValidators(int top) throws IOException ; + List getTopValidators(int top) throws IOException ; - BeaconChainDelegation getDelegation(String delegatorAddress, String validatorAddress) throws IOException; + Delegation getDelegation(String delegatorAddress, String validatorAddress) throws IOException; - List getDelegations(String delegatorAddress) throws IOException; + List getDelegations(String delegatorAddress) throws IOException; - BeaconChainRedelegation getRedelegation(String delegatorAddress, String srcValidatorAddress, String dstValidatorAddress) throws IOException; + Redelegation getRedelegation(String delegatorAddress, String srcValidatorAddress, String dstValidatorAddress) throws IOException; - List getRedelegations(String delegatorAddress) throws IOException; + List getRedelegations(String delegatorAddress) throws IOException; - BeaconChainUnBondingDelegation getUnBondingDelegation(String delegatorAddress, String validatorAddress) throws IOException; + UnBondingDelegation getUnBondingDelegation(String delegatorAddress, String validatorAddress) throws IOException; - List getUnBondingDelegations(String delegatorAddress) throws IOException; + List getUnBondingDelegations(String delegatorAddress) throws IOException; - List getUnBondingDelegationsByValidator(String validatorAddress) throws IOException ; + List getUnBondingDelegationsByValidator(String validatorAddress) throws IOException ; - List getRedelegationsByValidator(String validatorAddress) throws IOException; + List getRedelegationsByValidator(String validatorAddress) throws IOException; Pool getPool() throws IOException; @@ -281,17 +284,17 @@ default List unfreeze(TokenUnfreeze unfreeze, Wallet wallet List sideChainUnbond(SideChainUnBond sideChainUndelegate, Wallet wallet, TransactionOption options, boolean sync) throws IOException, NoSuchAlgorithmException; - SideChainValidator getSideChainValidator(String sideChainId, String validatorAddress) throws IOException; + Validator getSideChainValidator(String sideChainId, String validatorAddress) throws IOException; - List getSideChainTopValidators(String sideChainId, int top) throws IOException ; + List getSideChainTopValidators(String sideChainId, int top) throws IOException ; - SideChainDelegation getSideChainDelegation(String sideChainId, String delegatorAddress, String validatorAddress) throws IOException; + Delegation getSideChainDelegation(String sideChainId, String delegatorAddress, String validatorAddress) throws IOException; - List getSideChainDelegations(String sideChainId, String delegatorAddress) throws IOException; + List getSideChainDelegations(String sideChainId, String delegatorAddress) throws IOException; - SideChainRedelegation getSideChainRedelegation(String sideChainId, String delegatorAddress, String srcValidatorAddress, String dstValidatorAddress) throws IOException; + Redelegation getSideChainRedelegation(String sideChainId, String delegatorAddress, String srcValidatorAddress, String dstValidatorAddress) throws IOException; - List getSideChainRedelegations(String sideChainId, String delegatorAddress) throws IOException; + List getSideChainRedelegations(String sideChainId, String delegatorAddress) throws IOException; UnBondingDelegation getSideChainUnBondingDelegation(String sideChainId, String delegatorAddress, String validatorAddress) throws IOException; @@ -299,7 +302,7 @@ default List unfreeze(TokenUnfreeze unfreeze, Wallet wallet List getSideChainUnBondingDelegationsByValidator(String sideChainId, String validatorAddress) throws IOException ; - List getSideChainRedelegationsByValidator(String sideChainId, String validatorAddress) throws IOException; + List getSideChainRedelegationsByValidator(String sideChainId, String validatorAddress) throws IOException; Pool getSideChainPool(String sideChainId) throws IOException; diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainDelegation.java b/src/main/java/com/binance/dex/api/client/domain/stake/Delegation.java similarity index 56% rename from src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainDelegation.java rename to src/main/java/com/binance/dex/api/client/domain/stake/Delegation.java index 9a07436..1d0626f 100644 --- a/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainDelegation.java +++ b/src/main/java/com/binance/dex/api/client/domain/stake/Delegation.java @@ -1,29 +1,29 @@ -package com.binance.dex.api.client.domain.stake.sidechain; +package com.binance.dex.api.client.domain.stake; import com.binance.dex.api.client.encoding.message.Token; /** * @author Fitz.Lu **/ -public class SideChainDelegation { +public class Delegation { - private Delegation delegation; + private DelegationItem delegation; private Token balance; - public SideChainDelegation() { + public Delegation() { } - public SideChainDelegation(Delegation delegation, Token balance) { + public Delegation(DelegationItem delegation, Token balance) { this.delegation = delegation; this.balance = balance; } - public Delegation getDelegation() { + public DelegationItem getDelegation() { return delegation; } - public void setDelegation(Delegation delegation) { + public void setDelegation(DelegationItem delegation) { this.delegation = delegation; } diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/Delegation.java b/src/main/java/com/binance/dex/api/client/domain/stake/DelegationItem.java similarity index 86% rename from src/main/java/com/binance/dex/api/client/domain/stake/sidechain/Delegation.java rename to src/main/java/com/binance/dex/api/client/domain/stake/DelegationItem.java index 94b3ef5..437105d 100644 --- a/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/Delegation.java +++ b/src/main/java/com/binance/dex/api/client/domain/stake/DelegationItem.java @@ -1,9 +1,9 @@ -package com.binance.dex.api.client.domain.stake.sidechain; +package com.binance.dex.api.client.domain.stake; /** * @author Fitz.Lu **/ -public class Delegation { +public class DelegationItem { private String delegatorAddress; @@ -11,7 +11,7 @@ public class Delegation { private long shares; - public Delegation() { + public DelegationItem() { } public String getDelegatorAddress() { diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainRedelegation.java b/src/main/java/com/binance/dex/api/client/domain/stake/Redelegation.java similarity index 80% rename from src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainRedelegation.java rename to src/main/java/com/binance/dex/api/client/domain/stake/Redelegation.java index 94bd09e..4c6d84d 100644 --- a/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainRedelegation.java +++ b/src/main/java/com/binance/dex/api/client/domain/stake/Redelegation.java @@ -1,4 +1,4 @@ -package com.binance.dex.api.client.domain.stake.sidechain; +package com.binance.dex.api.client.domain.stake; import com.binance.dex.api.client.encoding.message.Token; @@ -6,7 +6,7 @@ /** * @author Fitz.Lu **/ -public class SideChainRedelegation { +public class Redelegation { //delegator address private String delegatorAddress; @@ -37,7 +37,20 @@ public class SideChainRedelegation { //amount of destination shares redelegating private long dstShare; - public SideChainRedelegation() { + public Redelegation(String delegatorAddress, String srcValidatorAddress, String dstValidatorAddress, long createHeight, String minTime, long minTimeInMs, Token initialBalance, Token balance, long srcShares, long dstShare) { + this.delegatorAddress = delegatorAddress; + this.srcValidatorAddress = srcValidatorAddress; + this.dstValidatorAddress = dstValidatorAddress; + this.createHeight = createHeight; + this.minTime = minTime; + this.minTimeInMs = minTimeInMs; + this.initialBalance = initialBalance; + this.balance = balance; + this.srcShares = srcShares; + this.dstShare = dstShare; + } + + public Redelegation() { } public String getDelegatorAddress() { diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/UnBondingDelegation.java b/src/main/java/com/binance/dex/api/client/domain/stake/UnBondingDelegation.java similarity index 78% rename from src/main/java/com/binance/dex/api/client/domain/stake/sidechain/UnBondingDelegation.java rename to src/main/java/com/binance/dex/api/client/domain/stake/UnBondingDelegation.java index b7ba0f8..8c96e98 100644 --- a/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/UnBondingDelegation.java +++ b/src/main/java/com/binance/dex/api/client/domain/stake/UnBondingDelegation.java @@ -1,4 +1,4 @@ -package com.binance.dex.api.client.domain.stake.sidechain; +package com.binance.dex.api.client.domain.stake; import com.binance.dex.api.client.encoding.message.Token; @@ -21,6 +21,19 @@ public class UnBondingDelegation { private Token balance; + public UnBondingDelegation() { + } + + public UnBondingDelegation(String delegatorAddress, String validatorAddress, long createHeight, long minTimeInMs, String minTime, Token initialBalance, Token balance) { + this.delegatorAddress = delegatorAddress; + this.validatorAddress = validatorAddress; + this.createHeight = createHeight; + this.minTimeInMs = minTimeInMs; + this.minTime = minTime; + this.initialBalance = initialBalance; + this.balance = balance; + } + public String getDelegatorAddress() { return delegatorAddress; } diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainValidator.java b/src/main/java/com/binance/dex/api/client/domain/stake/Validator.java similarity index 97% rename from src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainValidator.java rename to src/main/java/com/binance/dex/api/client/domain/stake/Validator.java index 1944dba..8a33e37 100644 --- a/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainValidator.java +++ b/src/main/java/com/binance/dex/api/client/domain/stake/Validator.java @@ -1,15 +1,14 @@ -package com.binance.dex.api.client.domain.stake.sidechain; +package com.binance.dex.api.client.domain.stake; import com.binance.dex.api.client.domain.stake.Commission; import com.binance.dex.api.client.domain.stake.Description; import java.util.ArrayList; -import java.util.Arrays; /** * @author Fitz.Lu **/ -public class SideChainValidator { +public class Validator { private String feeAddr; @@ -65,7 +64,7 @@ public void setAccumulatedStake(String accumulatedStake) { private String accumulatedStake; - public SideChainValidator() { + public Validator() { } public String getFeeAddr() { diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainDelegation.java b/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainDelegation.java deleted file mode 100644 index ac5da18..0000000 --- a/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainDelegation.java +++ /dev/null @@ -1,46 +0,0 @@ -package com.binance.dex.api.client.domain.stake.beaconchain; - -import com.binance.dex.api.client.domain.stake.sidechain.Delegation; -import com.binance.dex.api.client.domain.stake.sidechain.SideChainDelegation; -import com.binance.dex.api.client.encoding.message.Token; - -/** - * @author Francis.Liu - **/ -public class BeaconChainDelegation { - - private Delegation delegation; - - private Token balance; - - public BeaconChainDelegation() { - } - - public BeaconChainDelegation(Delegation delegation, Token balance) { - this.delegation = delegation; - this.balance = balance; - } - - public static BeaconChainDelegation createBySideChainDelegation(SideChainDelegation sideChainDelegation) { - BeaconChainDelegation delegation = new BeaconChainDelegation(); - delegation.setDelegation(sideChainDelegation.getDelegation()); - delegation.setBalance(sideChainDelegation.getBalance()); - return delegation; - } - - public Delegation getDelegation() { - return delegation; - } - - public void setDelegation(Delegation delegation) { - this.delegation = delegation; - } - - public Token getBalance() { - return balance; - } - - public void setBalance(Token balance) { - this.balance = balance; - } -} diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainRedelegation.java b/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainRedelegation.java deleted file mode 100644 index 7a4eeac..0000000 --- a/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainRedelegation.java +++ /dev/null @@ -1,167 +0,0 @@ -package com.binance.dex.api.client.domain.stake.beaconchain; - - -import com.binance.dex.api.client.domain.stake.sidechain.SideChainRedelegation; -import com.binance.dex.api.client.encoding.message.Token; - -/** - * @author Francis.Liu - **/ -public class BeaconChainRedelegation { - - //delegator address - private String delegatorAddress; - - //validator redelegation source operator address - private String srcValidatorAddress; - - //validator redelegation destination operator address - private String dstValidatorAddress; - - //height which the redelegation took place - private long createHeight; - - //unix time for redelegation completion - private String minTime; - - private long minTimeInMs; - - //initial balance when redelegation started - private Token initialBalance; - - //current balance - private Token balance; - - //amount of source shares redelegating - private long srcShares; - - //amount of destination shares redelegating - private long dstShare; - - public BeaconChainRedelegation() { - } - - public static BeaconChainRedelegation createBySideChainRedelegation(SideChainRedelegation sideChainRedelegation){ - BeaconChainRedelegation redelegation = new BeaconChainRedelegation(sideChainRedelegation.getDelegatorAddress(), - sideChainRedelegation.getSrcValidatorAddress(), - sideChainRedelegation.getDstValidatorAddress(), - sideChainRedelegation.getCreateHeight(), - sideChainRedelegation.getMinTime(), - sideChainRedelegation.getMinTimeInMs(), - sideChainRedelegation.getInitialBalance(), - sideChainRedelegation.getBalance(), - sideChainRedelegation.getSrcShares(), - sideChainRedelegation.getDstShare() - ); - return redelegation; - } - - public BeaconChainRedelegation(String delegatorAddress, String srcValidatorAddress, String dstValidatorAddress, long createHeight, String minTime, long minTimeInMs, Token initialBalance, Token balance, long srcShares, long dstShare) { - this.delegatorAddress = delegatorAddress; - this.srcValidatorAddress = srcValidatorAddress; - this.dstValidatorAddress = dstValidatorAddress; - this.createHeight = createHeight; - this.minTime = minTime; - this.minTimeInMs = minTimeInMs; - this.initialBalance = initialBalance; - this.balance = balance; - this.srcShares = srcShares; - this.dstShare = dstShare; - } - - public String getDelegatorAddress() { - return delegatorAddress; - } - - public void setDelegatorAddress(String delegatorAddress) { - this.delegatorAddress = delegatorAddress; - } - - public String getSrcValidatorAddress() { - return srcValidatorAddress; - } - - public void setSrcValidatorAddress(String srcValidatorAddress) { - this.srcValidatorAddress = srcValidatorAddress; - } - - public String getDstValidatorAddress() { - return dstValidatorAddress; - } - - public void setDstValidatorAddress(String dstValidatorAddress) { - this.dstValidatorAddress = dstValidatorAddress; - } - - public long getCreateHeight() { - return createHeight; - } - - public void setCreateHeight(long createHeight) { - this.createHeight = createHeight; - } - - public String getMinTime() { - return minTime; - } - - public void setMinTime(String minTime) { - this.minTime = minTime; - } - - public long getMinTimeInMs() { - return minTimeInMs; - } - - public void setMinTimeInMs(long minTimeInMs) { - this.minTimeInMs = minTimeInMs; - } - - public Token getInitialBalance() { - return initialBalance; - } - - public void setInitialBalance(Token initialBalance) { - this.initialBalance = initialBalance; - } - - public Token getBalance() { - return balance; - } - - public void setBalance(Token balance) { - this.balance = balance; - } - - public long getSrcShares() { - return srcShares; - } - - public void setSrcShares(long srcShares) { - this.srcShares = srcShares; - } - - public long getDstShare() { - return dstShare; - } - - public void setDstShare(long dstShare) { - this.dstShare = dstShare; - } - - @Override - public String toString() { - return "SideChainRedelegation{" + - "delegatorAddress='" + delegatorAddress + '\'' + - ", srcValidatorAddress='" + srcValidatorAddress + '\'' + - ", dstValidatorAddress='" + dstValidatorAddress + '\'' + - ", createHeight=" + createHeight + - ", minTime='" + minTime + '\'' + - ", minTimeInMs=" + minTimeInMs + - ", initialBalance=" + initialBalance + - ", balance=" + balance + - ", srcShares=" + srcShares + - ", dstShare=" + dstShare + - '}'; - } -} diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainUnBondingDelegation.java b/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainUnBondingDelegation.java deleted file mode 100644 index 4f46efe..0000000 --- a/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainUnBondingDelegation.java +++ /dev/null @@ -1,117 +0,0 @@ -package com.binance.dex.api.client.domain.stake.beaconchain; - -import com.binance.dex.api.client.domain.stake.sidechain.UnBondingDelegation; -import com.binance.dex.api.client.encoding.message.Token; - -/** - * @author Francis.Liu - **/ -public class BeaconChainUnBondingDelegation { - - private String delegatorAddress; - - private String validatorAddress; - - private long createHeight; - - private long minTimeInMs; - - private String minTime; - - private Token initialBalance; - - private Token balance; - - public BeaconChainUnBondingDelegation(String delegatorAddress, String validatorAddress, long createHeight, long minTimeInMs, String minTime, Token initialBalance, Token balance) { - this.delegatorAddress = delegatorAddress; - this.validatorAddress = validatorAddress; - this.createHeight = createHeight; - this.minTimeInMs = minTimeInMs; - this.minTime = minTime; - this.initialBalance = initialBalance; - this.balance = balance; - } - - public static BeaconChainUnBondingDelegation createByUnBondingDelegation(UnBondingDelegation unBondingDelegation) { - BeaconChainUnBondingDelegation beaconChainRedelegation = new BeaconChainUnBondingDelegation( - unBondingDelegation.getDelegatorAddress(), - unBondingDelegation.getValidatorAddress(), - unBondingDelegation.getCreateHeight(), - unBondingDelegation.getMinTimeInMs(), - unBondingDelegation.getMinTime(), - unBondingDelegation.getInitialBalance(), - unBondingDelegation.getBalance() - - ); - return beaconChainRedelegation; - } - - public String getDelegatorAddress() { - return delegatorAddress; - } - - public void setDelegatorAddress(String delegatorAddress) { - this.delegatorAddress = delegatorAddress; - } - - public String getValidatorAddress() { - return validatorAddress; - } - - public void setValidatorAddress(String validatorAddress) { - this.validatorAddress = validatorAddress; - } - - public long getCreateHeight() { - return createHeight; - } - - public void setCreateHeight(long createHeight) { - this.createHeight = createHeight; - } - - public long getMinTimeInMs() { - return minTimeInMs; - } - - public void setMinTimeInMs(long minTimeInMs) { - this.minTimeInMs = minTimeInMs; - } - - public String getMinTime() { - return minTime; - } - - public void setMinTime(String minTime) { - this.minTime = minTime; - } - - public Token getInitialBalance() { - return initialBalance; - } - - public void setInitialBalance(Token initialBalance) { - this.initialBalance = initialBalance; - } - - public Token getBalance() { - return balance; - } - - public void setBalance(Token balance) { - this.balance = balance; - } - - @Override - public String toString() { - return "UnBondingDelegation{" + - "delegatorAddress='" + delegatorAddress + '\'' + - ", validatorAddress='" + validatorAddress + '\'' + - ", createHeight=" + createHeight + - ", minTimeInMs=" + minTimeInMs + - ", minTime='" + minTime + '\'' + - ", initialBalance=" + initialBalance + - ", balance=" + balance + - '}'; - } -} diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainValidator.java b/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainValidator.java deleted file mode 100644 index 4b2a826..0000000 --- a/src/main/java/com/binance/dex/api/client/domain/stake/beaconchain/BeaconChainValidator.java +++ /dev/null @@ -1,207 +0,0 @@ -package com.binance.dex.api.client.domain.stake.beaconchain; - -import com.binance.dex.api.client.domain.stake.Commission; -import com.binance.dex.api.client.domain.stake.Description; -import com.binance.dex.api.client.domain.stake.sidechain.SideChainValidator; -import com.fasterxml.jackson.annotation.JsonIgnoreProperties; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.annotation.JsonPropertyOrder; - -import java.util.ArrayList; - -/** - * @author Francis.Liu - **/ -public class BeaconChainValidator { - - private String feeAddr; - private String operatorAddr; - private byte[] consPubKey; - private boolean jailed; - private int status; - private long tokens; - private long delegatorShares; - private Description description; - private long bondHeight; - private int bondIntraTxCounter; - private long unBondingHeight; - private long unBondingMinTime; - private Commission commission; - private String distributionAddr; - - private ArrayList stakeSnapShots; - - private String accumulatedStake; - - - public BeaconChainValidator() { - } - - public static BeaconChainValidator createBySideChainValidator(SideChainValidator sideChainValidator) { - BeaconChainValidator validator = new BeaconChainValidator(); - validator.setFeeAddr(sideChainValidator.getFeeAddr()); - validator.setOperatorAddr(sideChainValidator.getOperatorAddr()); - validator.setConsPubKey(sideChainValidator.getConsPubKey()); - validator.setJailed(sideChainValidator.isJailed()); - validator.setStatus(sideChainValidator.getStatus()); - validator.setTokens(sideChainValidator.getTokens()); - validator.setDelegatorShares(sideChainValidator.getDelegatorShares()); - validator.setDescription(sideChainValidator.getDescription()); - validator.setBondHeight(sideChainValidator.getBondHeight()); - validator.setBondIntraTxCounter(sideChainValidator.getBondIntraTxCounter()); - validator.setUnBondingHeight(sideChainValidator.getUnBondingHeight()); - validator.setCommission(sideChainValidator.getCommission()); - validator.setStakeSnapShots(sideChainValidator.getStakeSnapShots()); - validator.setAccumulatedStake(sideChainValidator.getAccumulatedStake()); - return validator; - } - - public String getFeeAddr() { - return feeAddr; - } - - public void setFeeAddr(String feeAddr) { - this.feeAddr = feeAddr; - } - - public String getOperatorAddr() { - return operatorAddr; - } - - public void setOperatorAddr(String operatorAddr) { - this.operatorAddr = operatorAddr; - } - - public byte[] getConsPubKey() { - return consPubKey; - } - - public void setConsPubKey(byte[] consPubKey) { - this.consPubKey = consPubKey; - } - - public boolean isJailed() { - return jailed; - } - - public void setJailed(boolean jailed) { - this.jailed = jailed; - } - - public int getStatus() { - return status; - } - - public void setStatus(int status) { - this.status = status; - } - - public long getTokens() { - return tokens; - } - - public void setTokens(long tokens) { - this.tokens = tokens; - } - - public long getDelegatorShares() { - return delegatorShares; - } - - public void setDelegatorShares(long delegatorShares) { - this.delegatorShares = delegatorShares; - } - - public Description getDescription() { - return description; - } - - public void setDescription(Description description) { - this.description = description; - } - - public long getBondHeight() { - return bondHeight; - } - - public void setBondHeight(long bondHeight) { - this.bondHeight = bondHeight; - } - - public int getBondIntraTxCounter() { - return bondIntraTxCounter; - } - - public void setBondIntraTxCounter(int bondIntraTxCounter) { - this.bondIntraTxCounter = bondIntraTxCounter; - } - - public long getUnBondingHeight() { - return unBondingHeight; - } - - public void setUnBondingHeight(long unBondingHeight) { - this.unBondingHeight = unBondingHeight; - } - - public long getUnBondingMinTime() { - return unBondingMinTime; - } - - public void setUnBondingMinTime(long unBondingMinTime) { - this.unBondingMinTime = unBondingMinTime; - } - - public Commission getCommission() { - return commission; - } - - public void setCommission(Commission commission) { - this.commission = commission; - } - - public String getDistributionAddr() { - return distributionAddr; - } - - public void setDistributionAddr(String distributionAddr) { - this.distributionAddr = distributionAddr; - } - - public ArrayList getStakeSnapShots() { - return stakeSnapShots; - } - - public void setStakeSnapShots(ArrayList stakeSnapShots) { - this.stakeSnapShots = stakeSnapShots; - } - - public String getAccumulatedStake() { - return accumulatedStake; - } - - public void setAccumulatedStake(String accumulatedStake) { - this.accumulatedStake = accumulatedStake; - } - - @Override - public String toString() { - return "SideChainValidator{" + - "feeAddr=" + feeAddr + '\n' + - ", operatorAddr=" + operatorAddr + '\n' + - ", consPubKey='" + consPubKey + '\'' + '\n' + - ", jailed=" + jailed + '\n' + - ", status=" + status + '\n' + - ", tokens=" + tokens + '\n' + - ", delegatorShares=" + delegatorShares + '\n' + - ", description=" + description + '\n' + - ", bondHeight=" + bondHeight + '\n' + - ", bondIntraTxCounter=" + bondIntraTxCounter + '\n' + - ", unBondingHeight=" + unBondingHeight + '\n' + - ", unBondingMinTime=" + unBondingMinTime + '\n' + - ", commission=" + commission + '\n' + - ", distributionAddr=" + distributionAddr + '\n' + - '}'; - } - -} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/query/BeaconChainRedelegationMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/query/BeaconChainRedelegationMessage.java index ca0c251..af8a577 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/query/BeaconChainRedelegationMessage.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/query/BeaconChainRedelegationMessage.java @@ -1,8 +1,7 @@ package com.binance.dex.api.client.encoding.message.beaconchain.query; -import com.binance.dex.api.client.domain.stake.beaconchain.BeaconChainRedelegation; -import com.binance.dex.api.client.domain.stake.sidechain.SideChainRedelegation; +import com.binance.dex.api.client.domain.stake.Redelegation; import com.binance.dex.api.client.encoding.message.Token; import com.fasterxml.jackson.annotation.JsonProperty; @@ -54,8 +53,8 @@ public class BeaconChainRedelegationMessage { public BeaconChainRedelegationMessage() { } - public BeaconChainRedelegation toBeaconChainRedelegation(){ - BeaconChainRedelegation redelegation = new BeaconChainRedelegation(this.getDelegatorAddress(), + public Redelegation toRedelegation(){ + Redelegation redelegation = new Redelegation(this.getDelegatorAddress(), this.getSrcValidatorAddress(), this.getDstValidatorAddress(), this.getCreateHeight(), diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/query/BeaconChainUnBondingDelegationMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/query/BeaconChainUnBondingDelegationMessage.java index ca6d1ea..9552359 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/query/BeaconChainUnBondingDelegationMessage.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/beaconchain/query/BeaconChainUnBondingDelegationMessage.java @@ -1,7 +1,6 @@ package com.binance.dex.api.client.encoding.message.beaconchain.query; -import com.binance.dex.api.client.domain.stake.beaconchain.BeaconChainUnBondingDelegation; -import com.binance.dex.api.client.domain.stake.sidechain.UnBondingDelegation; +import com.binance.dex.api.client.domain.stake.UnBondingDelegation; import com.binance.dex.api.client.encoding.message.Token; import com.fasterxml.jackson.annotation.JsonProperty; @@ -29,8 +28,8 @@ public class BeaconChainUnBondingDelegationMessage { @JsonProperty(value = "cross_stake") private boolean crossStake; - public BeaconChainUnBondingDelegation toBeaconChainUnBondingDelegation() { - BeaconChainUnBondingDelegation beaconChainRedelegation = new BeaconChainUnBondingDelegation( + public UnBondingDelegation toBeaconChainUnBondingDelegation() { + UnBondingDelegation redelegation = new UnBondingDelegation( this.getDelegatorAddress(), this.getValidatorAddress(), this.getCreateHeight(), @@ -40,7 +39,7 @@ public BeaconChainUnBondingDelegation toBeaconChainUnBondingDelegation() { this.getBalance() ); - return beaconChainRedelegation; + return redelegation; } public String getDelegatorAddress() { diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/BechValidator.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/BechValidator.java index 179e8f6..ed7d48d 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/BechValidator.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/query/BechValidator.java @@ -2,8 +2,7 @@ import com.binance.dex.api.client.domain.stake.Commission; import com.binance.dex.api.client.domain.stake.Description; -import com.binance.dex.api.client.domain.stake.sidechain.SideChainValidator; -import com.binance.dex.api.client.encoding.Crypto; +import com.binance.dex.api.client.domain.stake.Validator; import com.binance.dex.api.client.encoding.amino.Amino; import com.binance.dex.api.client.encoding.message.sidechain.value.DescriptionValue; import com.fasterxml.jackson.annotation.JsonProperty; @@ -143,8 +142,8 @@ public BechValidator() { } - public SideChainValidator toSideChainValidator() { - SideChainValidator validator = new SideChainValidator(); + public Validator toValidator() { + Validator validator = new Validator(); if (feeAddr != null) { validator.setFeeAddr(feeAddr); } diff --git a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java index abb0f1d..ee1835f 100644 --- a/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java +++ b/src/main/java/com/binance/dex/api/client/impl/BinanceDexApiNodeClientImpl.java @@ -2,12 +2,15 @@ import com.binance.dex.api.client.*; import com.binance.dex.api.client.domain.*; -import com.binance.dex.api.client.domain.bridge.TransferIn; import com.binance.dex.api.client.domain.broadcast.SideVote; import com.binance.dex.api.client.domain.oracle.Prophecy; import com.binance.dex.api.client.domain.StakeValidator; import com.binance.dex.api.client.domain.stake.Pool; import com.binance.dex.api.client.domain.stake.beaconchain.*; +import com.binance.dex.api.client.domain.stake.Delegation; +import com.binance.dex.api.client.domain.stake.Redelegation; +import com.binance.dex.api.client.domain.stake.UnBondingDelegation; +import com.binance.dex.api.client.domain.stake.Validator; import com.binance.dex.api.client.domain.stake.sidechain.*; import com.binance.dex.api.client.domain.broadcast.Transaction; import com.binance.dex.api.client.domain.broadcast.*; @@ -451,32 +454,32 @@ public List sideChainUnbond(SideChainUnBond sideChainUndele } @Override - public SideChainValidator getSideChainValidator(String sideChainId, String validatorAddress) throws IOException { + public Validator getSideChainValidator(String sideChainId, String validatorAddress) throws IOException { return sideChainQueryDelegate.querySideChainValidator(sideChainId, validatorAddress); } @Override - public List getSideChainTopValidators(String sideChainId, int top) throws IOException { + public List getSideChainTopValidators(String sideChainId, int top) throws IOException { return sideChainQueryDelegate.querySideChainTopValidators(sideChainId, top); } @Override - public SideChainDelegation getSideChainDelegation(String sideChainId, String delegatorAddress, String validatorAddress) throws IOException { + public Delegation getSideChainDelegation(String sideChainId, String delegatorAddress, String validatorAddress) throws IOException { return sideChainQueryDelegate.querySideChainDelegation(sideChainId, delegatorAddress, validatorAddress); } @Override - public List getSideChainDelegations(String sideChainId, String delegatorAddress) throws IOException { + public List getSideChainDelegations(String sideChainId, String delegatorAddress) throws IOException { return sideChainQueryDelegate.querySideChainDelegations(sideChainId, delegatorAddress); } @Override - public SideChainRedelegation getSideChainRedelegation(String sideChainId, String delegatorAddress, String srcValidatorAddress, String dstValidatorAddress) throws IOException { + public Redelegation getSideChainRedelegation(String sideChainId, String delegatorAddress, String srcValidatorAddress, String dstValidatorAddress) throws IOException { return sideChainQueryDelegate.querySideChainRedelegation(sideChainId, delegatorAddress, srcValidatorAddress, dstValidatorAddress); } @Override - public List getSideChainRedelegations(String sideChainId, String delegatorAddress) throws IOException { + public List getSideChainRedelegations(String sideChainId, String delegatorAddress) throws IOException { return sideChainQueryDelegate.querySideChainRedelegations(sideChainId, delegatorAddress); } @@ -496,7 +499,7 @@ public List getSideChainUnBondingDelegationsByValidator(Str } @Override - public List getSideChainRedelegationsByValidator(String sideChainId, String validatorAddress) throws IOException { + public List getSideChainRedelegationsByValidator(String sideChainId, String validatorAddress) throws IOException { return sideChainQueryDelegate.querySideChainRedelegationsByValidator(sideChainId, validatorAddress); } @@ -634,52 +637,52 @@ public List undelegate(BeaconChainUndelegate beaconChainUnd } @Override - public BeaconChainValidator getValidator(String validatorAddress) throws IOException { + public Validator getValidator(String validatorAddress) throws IOException { return beaconChainQueryDelegate.queryBeaconChainValidator(validatorAddress); } @Override - public List getTopValidators(int top) throws IOException { + public List getTopValidators(int top) throws IOException { return beaconChainQueryDelegate.queryBeaconChainTopValidators(top); } @Override - public BeaconChainDelegation getDelegation(String delegatorAddress, String validatorAddress) throws IOException { + public Delegation getDelegation(String delegatorAddress, String validatorAddress) throws IOException { return beaconChainQueryDelegate.queryBeaconChainDelegation(delegatorAddress, validatorAddress); } @Override - public List getDelegations(String delegatorAddress) throws IOException { + public List getDelegations(String delegatorAddress) throws IOException { return beaconChainQueryDelegate.queryBeaconChainDelegations(delegatorAddress); } @Override - public BeaconChainRedelegation getRedelegation(String delegatorAddress, String srcValidatorAddress, String dstValidatorAddress) throws IOException { + public Redelegation getRedelegation(String delegatorAddress, String srcValidatorAddress, String dstValidatorAddress) throws IOException { return beaconChainQueryDelegate.queryBeaconChainRedelegation(delegatorAddress, srcValidatorAddress, dstValidatorAddress); } @Override - public List getRedelegations(String delegatorAddress) throws IOException { + public List getRedelegations(String delegatorAddress) throws IOException { return beaconChainQueryDelegate.queryBeaconChainRedelegations(delegatorAddress); } @Override - public BeaconChainUnBondingDelegation getUnBondingDelegation(String delegatorAddress, String validatorAddress) throws IOException { + public UnBondingDelegation getUnBondingDelegation(String delegatorAddress, String validatorAddress) throws IOException { return beaconChainQueryDelegate.queryBeaconChainUnBondingDelegation(delegatorAddress, validatorAddress); } @Override - public List getUnBondingDelegations(String delegatorAddress) throws IOException { + public List getUnBondingDelegations(String delegatorAddress) throws IOException { return beaconChainQueryDelegate.queryBeaconChainUnBondingDelegations(delegatorAddress); } @Override - public List getUnBondingDelegationsByValidator(String validatorAddress) throws IOException { + public List getUnBondingDelegationsByValidator(String validatorAddress) throws IOException { return beaconChainQueryDelegate.queryBeaconChainUnBondingDelegationsByValidator(validatorAddress); } @Override - public List getRedelegationsByValidator(String validatorAddress) throws IOException { + public List getRedelegationsByValidator(String validatorAddress) throws IOException { return beaconChainQueryDelegate.queryBeaconChainRedelegationsByValidator(validatorAddress); } diff --git a/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegateBeaconChainStaking.java b/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegateBeaconChainStaking.java index f3db244..20d27d6 100644 --- a/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegateBeaconChainStaking.java +++ b/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegateBeaconChainStaking.java @@ -2,11 +2,10 @@ import com.binance.dex.api.client.BinanceDexNodeApi; import com.binance.dex.api.client.domain.stake.Pool; -import com.binance.dex.api.client.domain.stake.beaconchain.BeaconChainDelegation; -import com.binance.dex.api.client.domain.stake.beaconchain.BeaconChainRedelegation; -import com.binance.dex.api.client.domain.stake.beaconchain.BeaconChainUnBondingDelegation; -import com.binance.dex.api.client.domain.stake.beaconchain.BeaconChainValidator; -import com.binance.dex.api.client.domain.stake.sidechain.*; +import com.binance.dex.api.client.domain.stake.Delegation; +import com.binance.dex.api.client.domain.stake.Redelegation; +import com.binance.dex.api.client.domain.stake.UnBondingDelegation; +import com.binance.dex.api.client.domain.stake.Validator; import com.binance.dex.api.client.encoding.ByteUtil; import com.binance.dex.api.client.encoding.EncodeUtils; import com.binance.dex.api.client.encoding.message.beaconchain.query.BeaconChainRedelegationMessage; @@ -34,42 +33,33 @@ public NodeQueryDelegateBeaconChainStaking(BinanceDexNodeApi binanceDexNodeApi, this.sideChainStakingQuery = sideChainStakingQuery; } - public BeaconChainValidator queryBeaconChainValidator(String validatorAddress) throws IOException { + public Validator queryBeaconChainValidator(String validatorAddress) throws IOException { QueryValidatorParams params = new QueryValidatorParams(sideChainId, Bech32AddressValue.fromBech32StringWithNewHrp(validatorAddress, valHrp)); byte[] data = EncodeUtils.toJsonEncodeBytes(params); byte[] result = queryWithData("\"custom/stake/validator\"", data); if (!ByteUtil.isEmpty(result)){ String jsonStr = new String(result); BechValidator validator = EncodeUtils.getObjectMapper().readValue(jsonStr, new TypeReference(){}); - return BeaconChainValidator.createBySideChainValidator(validator.toSideChainValidator()); + return validator.toValidator(); } return null; } - public List queryBeaconChainTopValidators(int top) throws IOException { - List validators = this.sideChainStakingQuery.querySideChainTopValidators(sideChainId, top); - - List beaconChainValidators = new ArrayList<>(); - for (SideChainValidator validator : validators) { - beaconChainValidators.add(BeaconChainValidator.createBySideChainValidator(validator)); - } - return beaconChainValidators; + public List queryBeaconChainTopValidators(int top) throws IOException { + List validators = this.sideChainStakingQuery.querySideChainTopValidators(sideChainId, top); + return validators; } - public BeaconChainDelegation queryBeaconChainDelegation(String delegatorAddress, String validatorAddress) throws IOException { - return BeaconChainDelegation.createBySideChainDelegation(this.sideChainStakingQuery.querySideChainDelegation(sideChainId, delegatorAddress, validatorAddress)); + public Delegation queryBeaconChainDelegation(String delegatorAddress, String validatorAddress) throws IOException { + return this.sideChainStakingQuery.querySideChainDelegation(sideChainId, delegatorAddress, validatorAddress); } - public List queryBeaconChainDelegations(String delegatorAddress) throws IOException { - List results = new ArrayList<>(); - List delegations = this.sideChainStakingQuery.querySideChainDelegations(sideChainId, delegatorAddress); - for(SideChainDelegation delegation: delegations){ - results.add(BeaconChainDelegation.createBySideChainDelegation(delegation)); - } - return results; + public List queryBeaconChainDelegations(String delegatorAddress) throws IOException { + List delegations = this.sideChainStakingQuery.querySideChainDelegations(sideChainId, delegatorAddress); + return delegations; } - public BeaconChainRedelegation queryBeaconChainRedelegation(String delegatorAddress, String srcValidatorAddress, String dstValidatorAddress) throws IOException { + public Redelegation queryBeaconChainRedelegation(String delegatorAddress, String srcValidatorAddress, String dstValidatorAddress) throws IOException { QueryRedelegationParams params = new QueryRedelegationParams(sideChainId, delegatorAddress, srcValidatorAddress, dstValidatorAddress); byte[] data = EncodeUtils.toJsonEncodeBytes(params); byte[] result = queryWithData("\"custom/stake/redelegation\"", data); @@ -77,29 +67,29 @@ public BeaconChainRedelegation queryBeaconChainRedelegation(String delegatorAddr if (!ByteUtil.isEmpty(result)){ String jsonStr = new String(result); BeaconChainRedelegationMessage message = EncodeUtils.getObjectMapper().readValue(jsonStr, new TypeReference(){}); - return message.toBeaconChainRedelegation(); + return message.toRedelegation(); } return null; } - public List queryBeaconChainRedelegations(String delegatorAddress) throws IOException { + public List queryBeaconChainRedelegations(String delegatorAddress) throws IOException { QueryDelegatorParams params = new QueryDelegatorParams(); params.setDelegatorAddr(delegatorAddress); byte[] data = EncodeUtils.toJsonEncodeBytes(params); byte[] result = queryWithData("\"custom/stake/delegatorRedelegations\"", data); - List results = new ArrayList<>(); + List results = new ArrayList<>(); if (!ByteUtil.isEmpty(result)){ String jsonStr = new String(result); List messages = EncodeUtils.getObjectMapper().readValue(jsonStr, new TypeReference>(){}); for (BeaconChainRedelegationMessage message : messages) { - results.add(message.toBeaconChainRedelegation()); + results.add(message.toRedelegation()); } } return results; } - public BeaconChainUnBondingDelegation queryBeaconChainUnBondingDelegation(String delegatorAddress, String validatorAddress) throws IOException { + public UnBondingDelegation queryBeaconChainUnBondingDelegation(String delegatorAddress, String validatorAddress) throws IOException { QueryBondsParams params = new QueryBondsParams(); params.setDelegatorAddr(delegatorAddress); params.setValidatorAddr(validatorAddress); @@ -114,12 +104,12 @@ public BeaconChainUnBondingDelegation queryBeaconChainUnBondingDelegation(String return null; } - public List queryBeaconChainUnBondingDelegations(String delegatorAddress) throws IOException { + public List queryBeaconChainUnBondingDelegations(String delegatorAddress) throws IOException { QueryDelegatorParams params = new QueryDelegatorParams(); params.setDelegatorAddr(delegatorAddress); byte[] data = EncodeUtils.toJsonEncodeBytes(params); byte[] result = queryWithData("\"custom/stake/delegatorUnbondingDelegations\"", data); - List results = new ArrayList<>(); + List results = new ArrayList<>(); if (!ByteUtil.isEmpty(result)){ String jsonStr = new String(result); List messages = EncodeUtils.getObjectMapper().readValue(jsonStr, new TypeReference>(){}); @@ -130,26 +120,14 @@ public List queryBeaconChainUnBondingDelegations return results; } - public List queryBeaconChainUnBondingDelegationsByValidator(String validatorAddress) throws IOException { - List beaconChainUnBondingDelegations = new ArrayList<>(); + public List queryBeaconChainUnBondingDelegationsByValidator(String validatorAddress) throws IOException { List unBondingDelegations = this.sideChainStakingQuery.querySideChainUnBondingDelegationsByValidator(sideChainId, validatorAddress); - - for (UnBondingDelegation unBondingDelegation : unBondingDelegations) { - beaconChainUnBondingDelegations.add(BeaconChainUnBondingDelegation.createByUnBondingDelegation(unBondingDelegation)); - } - - return beaconChainUnBondingDelegations; + return unBondingDelegations; } - public List queryBeaconChainRedelegationsByValidator(String validatorAddress) throws IOException { - List beaconChainRedelegations = new ArrayList<>(); - List sideChainRedelegations = this.sideChainStakingQuery.querySideChainRedelegationsByValidator(sideChainId, validatorAddress); - - for (SideChainRedelegation sideChainRedelegation : sideChainRedelegations) { - beaconChainRedelegations.add(BeaconChainRedelegation.createBySideChainRedelegation(sideChainRedelegation)); - } - - return beaconChainRedelegations; + public List queryBeaconChainRedelegationsByValidator(String validatorAddress) throws IOException { + List redelegations = this.sideChainStakingQuery.querySideChainRedelegationsByValidator(sideChainId, validatorAddress); + return redelegations; } public Pool queryBeaconChainPool() throws IOException { diff --git a/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegateSideChainStaking.java b/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegateSideChainStaking.java index 1f7abe7..ea99d5b 100644 --- a/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegateSideChainStaking.java +++ b/src/main/java/com/binance/dex/api/client/impl/node/NodeQueryDelegateSideChainStaking.java @@ -1,11 +1,8 @@ package com.binance.dex.api.client.impl.node; import com.binance.dex.api.client.*; -import com.binance.dex.api.client.domain.stake.Commission; -import com.binance.dex.api.client.domain.stake.Description; -import com.binance.dex.api.client.domain.stake.Pool; -import com.binance.dex.api.client.domain.stake.sidechain.*; -import com.binance.dex.api.client.domain.stake.sidechain.Delegation; +import com.binance.dex.api.client.domain.stake.*; +import com.binance.dex.api.client.domain.stake.Delegation; import com.binance.dex.api.client.encoding.ByteUtil; import com.binance.dex.api.client.encoding.Crypto; import com.binance.dex.api.client.encoding.EncodeUtils; @@ -52,7 +49,7 @@ public NodeQueryDelegateSideChainStaking(BinanceDexNodeApi binanceDexNodeApi, St amino = InternalAmino.get(); } - public SideChainValidator querySideChainValidator(String sideChainId, String validatorAddress) throws IOException { + public Validator querySideChainValidator(String sideChainId, String validatorAddress) throws IOException { byte[] storePrefix = getSideChainStorePrefixKey(sideChainId); byte[] key = ByteUtil.appendBytesArray(storePrefix, getValidatorKey(Crypto.decodeAddress(validatorAddress))); byte[] result = queryStore(stakeStoreName, key); @@ -66,7 +63,7 @@ public SideChainValidator querySideChainValidator(String sideChainId, String val } } - public List querySideChainTopValidators(String sideChainId, int top) throws IOException { + public List querySideChainTopValidators(String sideChainId, int top) throws IOException { if (top > 50 || top < 1){ throw new IllegalArgumentException("top must be between 1 and 50"); } @@ -81,19 +78,19 @@ public List querySideChainTopValidators(String sideChainId, List bechValidator = EncodeUtils.getObjectMapper().readValue(jsonStr, new TypeReference>(){}); - List sideChainValidators = new ArrayList<>(); + List sideChainValidators = new ArrayList<>(); if (bechValidator != null && !bechValidator.isEmpty()){ for (BechValidator validator : bechValidator) { - sideChainValidators.add(validator.toSideChainValidator()); + sideChainValidators.add(validator.toValidator()); } } return sideChainValidators; } - private SideChainValidator convert(SideChainValidatorMessage message){ - SideChainValidator sideChainValidator = new SideChainValidator(); + private Validator convert(SideChainValidatorMessage message){ + Validator sideChainValidator = new Validator(); if (message.getFeeAddr() != null) { sideChainValidator.setFeeAddr(EncodeUtils.bytesToPrefixHex(message.getFeeAddr())); @@ -168,7 +165,7 @@ private SideChainValidator convert(SideChainValidatorMessage message){ return sideChainValidator; } - public SideChainDelegation querySideChainDelegation(String sideChainId, String delegatorAddress, String validatorAddress) throws IOException { + public Delegation querySideChainDelegation(String sideChainId, String delegatorAddress, String validatorAddress) throws IOException { QueryBondsParams params = new QueryBondsParams(); params.setSideChainId(sideChainId); params.setDelegatorAddr(delegatorAddress); @@ -185,7 +182,7 @@ public SideChainDelegation querySideChainDelegation(String sideChainId, String d return null; } - public List querySideChainDelegations(String sideChainId, String delegatorAddress) throws IOException { + public List querySideChainDelegations(String sideChainId, String delegatorAddress) throws IOException { QueryDelegatorParams params = new QueryDelegatorParams(); params.setSideChainId(sideChainId); params.setDelegatorAddr(delegatorAddress); @@ -193,7 +190,7 @@ public List querySideChainDelegations(String sideChainId, S byte[] paramsBytes = EncodeUtils.toJsonEncodeBytes(params); byte[] response = queryWithData("\"custom/stake/delegatorDelegations\"", paramsBytes); - List results = new ArrayList<>(); + List results = new ArrayList<>(); if (!ByteUtil.isEmpty(response)){ String a = new String(response); @@ -206,10 +203,10 @@ public List querySideChainDelegations(String sideChainId, S return results; } - private SideChainDelegation convert(DelegationResponse delegationResponse){ - SideChainDelegation sideChainDelegation = new SideChainDelegation(); + private Delegation convert(DelegationResponse delegationResponse){ + Delegation sideChainDelegation = new Delegation(); if (delegationResponse.getDelegation() != null) { - Delegation delegation = new Delegation(); + DelegationItem delegation = new DelegationItem(); delegation.setDelegatorAddress(delegationResponse.getDelegation().getDelegatorAddress()); delegation.setValidatorAddress(delegationResponse.getDelegation().getValidatorAddress()); delegation.setShares(delegationResponse.getDelegation().getShares()); @@ -222,7 +219,7 @@ private SideChainDelegation convert(DelegationResponse delegationResponse){ return sideChainDelegation; } - public SideChainRedelegation querySideChainRedelegation(String sideChainId, String delegatorAddress, String srcValidatorAddress, String dstValidatorAddress) throws IOException { + public Redelegation querySideChainRedelegation(String sideChainId, String delegatorAddress, String srcValidatorAddress, String dstValidatorAddress) throws IOException { byte[] storePrefix = getSideChainStorePrefixKey(sideChainId); byte[] redKey = getRedelegationKey(Crypto.decodeAddress(delegatorAddress), Crypto.decodeAddress(srcValidatorAddress), Crypto.decodeAddress(dstValidatorAddress)); @@ -238,12 +235,12 @@ public SideChainRedelegation querySideChainRedelegation(String sideChainId, Stri return null; } - public List querySideChainRedelegations(String sideChainId, String delegatorAddress) throws IOException { + public List querySideChainRedelegations(String sideChainId, String delegatorAddress) throws IOException { byte[] storePrefix = getSideChainStorePrefixKey(sideChainId); byte[] redsKey = getRedelegationsKey(Crypto.decodeAddress(delegatorAddress)); byte[] key = ByteUtil.appendBytesArray(storePrefix, redsKey); List result = queryStoreSubspaceKVPairs(stakeStoreName, key); - List redelegations = new ArrayList<>(); + List redelegations = new ArrayList<>(); if (result != null && !result.isEmpty()){ for (common.Types.KVPair kvPair : result) { byte[] k = ByteUtil.cut(kvPair.getKey().toByteArray(), storePrefix.length); @@ -256,7 +253,7 @@ public List querySideChainRedelegations(String sideChainI return redelegations; } - private SideChainRedelegation convert(RedelegationValue value, byte[] key){ + private Redelegation convert(RedelegationValue value, byte[] key){ byte[] addresses = ByteUtil.cut(key, 1); if (addresses.length != addressLength * 3){ throw new IllegalStateException("unexpected address length for (address, srcValidator, dstValidator)"); @@ -266,7 +263,7 @@ private SideChainRedelegation convert(RedelegationValue value, byte[] key){ String srcValAddr = Crypto.encodeAddress(valHrp, ByteUtil.pick(addresses, addressLength, addressLength)); String dstValAddr = Crypto.encodeAddress(valHrp, ByteUtil.pick(addresses, addressLength * 2, addressLength)); - SideChainRedelegation redelegation = new SideChainRedelegation(); + Redelegation redelegation = new Redelegation(); redelegation.setDelegatorAddress(delAddr); redelegation.setSrcValidatorAddress(srcValAddr); redelegation.setDstValidatorAddress(dstValAddr); @@ -343,12 +340,12 @@ public List querySideChainUnBondingDelegationsByValidator(S return unBondingDelegations; } - public List querySideChainRedelegationsByValidator(String sideChainId, String validatorAddress) throws IOException { + public List querySideChainRedelegationsByValidator(String sideChainId, String validatorAddress) throws IOException { QueryValidatorParams params = new QueryValidatorParams(sideChainId, Bech32AddressValue.fromBech32StringWithNewHrp(validatorAddress, valHrp)); byte[] data = EncodeUtils.toJsonEncodeBytes(params); byte[] result = queryWithData("\"custom/stake/validatorRedelegations\"", data); - List redelegations = new ArrayList<>(); + List redelegations = new ArrayList<>(); if (!ByteUtil.isEmpty(result)){ List messages = EncodeUtils.getObjectMapper().readValue(result, new TypeReference>(){}); @@ -405,8 +402,8 @@ public long queryAllSideChainValidatorsCount(String sideChainId, boolean jailInv return 0L; } - private SideChainRedelegation convert(SideChainRedelegationMessage message){ - SideChainRedelegation redelegation = new SideChainRedelegation(); + private Redelegation convert(SideChainRedelegationMessage message){ + Redelegation redelegation = new Redelegation(); redelegation.setDelegatorAddress(message.getDelegatorAddress()); redelegation.setSrcValidatorAddress(message.getSrcValidatorAddress()); redelegation.setDstValidatorAddress(message.getDstValidatorAddress()); diff --git a/src/test/java/com/binance/dex/api/client/examples/BeaconChainStakingNodeExample.java b/src/test/java/com/binance/dex/api/client/examples/BeaconChainStakingNodeExample.java index 2c9ec89..4e2c8ac 100644 --- a/src/test/java/com/binance/dex/api/client/examples/BeaconChainStakingNodeExample.java +++ b/src/test/java/com/binance/dex/api/client/examples/BeaconChainStakingNodeExample.java @@ -9,9 +9,7 @@ import com.binance.dex.api.client.domain.TransactionMetadata; import com.binance.dex.api.client.domain.broadcast.TransactionOption; import com.binance.dex.api.client.domain.broadcast.Transfer; -import com.binance.dex.api.client.domain.stake.Commission; -import com.binance.dex.api.client.domain.stake.Description; -import com.binance.dex.api.client.domain.stake.Pool; +import com.binance.dex.api.client.domain.stake.*; import com.binance.dex.api.client.domain.stake.beaconchain.*; import com.binance.dex.api.client.domain.stake.sidechain.CreateSideChainValidator; import com.binance.dex.api.client.domain.stake.sidechain.EditSideChainValidator; @@ -200,15 +198,15 @@ public void testStaking() throws IOException, NoSuchAlgorithmException { // query top validators int topValidatorNum = 3; - List topValidators = nodeClient.getTopValidators(topValidatorNum); + List topValidators = nodeClient.getTopValidators(topValidatorNum); logger.info(String.format("top validators %s \n", topValidators)); Assert.assertTrue("top validators should be 1", topValidators.size() == topValidatorNum); - BeaconChainValidator topValidator = topValidators.get(0); + Validator topValidator = topValidators.get(0); // query validator String validator0ValAddr = Crypto.getAddressFromPrivateKey(validator0.getPrivateKey(), env.getValHrp()); logger.info(String.format("validator addr %s \n", validator0ValAddr)); - BeaconChainValidator validator = nodeClient.getValidator(validator0ValAddr); + Validator validator = nodeClient.getValidator(validator0ValAddr); logger.info(String.format("query validator: %s \n", validator)); Assert.assertNotNull("validator should not be nil", validator); Assert.assertEquals("validator address should be equal", validator.getFeeAddr(), validator0.getAddress()); @@ -245,29 +243,29 @@ public void testStaking() throws IOException, NoSuchAlgorithmException { Assert.assertEquals("delegate tokens should be equal", tokenAfterDelegate - tokenBeforeDelegate, delegateAmount); // query delegation - BeaconChainDelegation delegationQuery = nodeClient.getDelegation(delegator.getAddress(), validator0ValAddr); + Delegation delegationQuery = nodeClient.getDelegation(delegator.getAddress(), validator0ValAddr); logger.info(String.format("query delegation: %s \n", delegationQuery)); Assert.assertEquals("delegation shares should be equal", delegationQuery.getDelegation().getShares(), delegateAmount); // query delegations - List delegations = nodeClient.getDelegations(delegator.getAddress()); + List delegations = nodeClient.getDelegations(delegator.getAddress()); logger.info(String.format("query delegations: %s \n", delegations)); // check redelegate preparation String topValAddr = topValidator.getOperatorAddr(); - BeaconChainValidator topValidatorBeforeRedelegate = nodeClient.getValidator(topValAddr); + Validator topValidatorBeforeRedelegate = nodeClient.getValidator(topValAddr); logger.info(String.format("top validator before redelegate: %s \n", topValidatorBeforeRedelegate)); // redelegate from validator0 to top validator, should success immediately long redelegateAmount = 200000000L; this.beaconChainRedelegate(delegator, validator0.getAddress(), topValAddr, redelegateAmount); - BeaconChainValidator topValidatorAfterRedelegate = nodeClient.getValidator(topValAddr); + Validator topValidatorAfterRedelegate = nodeClient.getValidator(topValAddr); logger.info(String.format("top validator after redelegate: %s \n", topValidatorAfterRedelegate)); Assert.assertEquals("redelegate tokens should be equal", topValidatorAfterRedelegate.getTokens() - topValidatorBeforeRedelegate.getTokens(), redelegateAmount); // undelegate this.beaconChainUndelegate(delegator, topValAddr, redelegateAmount); - BeaconChainValidator topValidatorAfterUndelegate = nodeClient.getValidator(topValAddr); + Validator topValidatorAfterUndelegate = nodeClient.getValidator(topValAddr); logger.info(String.format("top validator after undelegate: %s \n", topValidatorAfterUndelegate)); Assert.assertEquals("check undelegation token change", topValidatorAfterUndelegate.getTokens(), topValidatorBeforeRedelegate.getTokens()); @@ -276,15 +274,15 @@ public void testStaking() throws IOException, NoSuchAlgorithmException { logger.info(String.format("pool: %s \n", pool)); // query unbonding delegation - BeaconChainUnBondingDelegation unbondingDelegation = nodeClient.getUnBondingDelegation(delegator.getAddress(), topValAddr); + UnBondingDelegation unbondingDelegation = nodeClient.getUnBondingDelegation(delegator.getAddress(), topValAddr); logger.info(String.format("query unbonding delegation: %s \n", unbondingDelegation)); // query unbonding delegations - List unbondingDelegations = nodeClient.getUnBondingDelegations(delegator.getAddress()); + List unbondingDelegations = nodeClient.getUnBondingDelegations(delegator.getAddress()); logger.info(String.format("query unbonding delegations: %s \n", unbondingDelegations)); // query unbonding delegations by validator - List unbondingDelegationsByValidator = nodeClient.getUnBondingDelegationsByValidator(topValAddr); + List unbondingDelegationsByValidator = nodeClient.getUnBondingDelegationsByValidator(topValAddr); logger.info(String.format("query unbonding delegations by validator: %s \n", unbondingDelegationsByValidator)); // delegate to top validator and then redelegate @@ -297,17 +295,17 @@ public void testStaking() throws IOException, NoSuchAlgorithmException { this.beaconChainRedelegate(delegator0, topValAddr, validator0.getAddress(), delegateAmount); // query redelegation - BeaconChainRedelegation redelegation = nodeClient.getRedelegation(delegator0.getAddress(), topValAddr, validator0ValAddr); + Redelegation redelegation = nodeClient.getRedelegation(delegator0.getAddress(), topValAddr, validator0ValAddr); logger.info(String.format("query redelegation: %s \n", redelegation)); Assert.assertNotNull("redelegation should not be nil", redelegation); // query redelegations - List redelegations = nodeClient.getRedelegations(delegator0.getAddress()); + List redelegations = nodeClient.getRedelegations(delegator0.getAddress()); logger.info(String.format("query redelegations: %s \n", redelegations)); Assert.assertTrue("redelegations should not be empty", redelegations.size() > 0); // query redelegations by source validator - List redelegationsByValidator = nodeClient.getRedelegationsByValidator(topValAddr); + List redelegationsByValidator = nodeClient.getRedelegationsByValidator(topValAddr); logger.info(String.format("query redelegations by validator: %s \n", redelegationsByValidator)); Assert.assertTrue("redelegations by validator should not be empty", redelegationsByValidator.size() > 0); diff --git a/src/test/java/com/binance/dex/api/client/examples/SideChainStakingNodeExample.java b/src/test/java/com/binance/dex/api/client/examples/SideChainStakingNodeExample.java index d9b924a..21d2872 100644 --- a/src/test/java/com/binance/dex/api/client/examples/SideChainStakingNodeExample.java +++ b/src/test/java/com/binance/dex/api/client/examples/SideChainStakingNodeExample.java @@ -9,6 +9,10 @@ import com.binance.dex.api.client.domain.stake.Commission; import com.binance.dex.api.client.domain.stake.Description; import com.binance.dex.api.client.domain.stake.Pool; +import com.binance.dex.api.client.domain.stake.Delegation; +import com.binance.dex.api.client.domain.stake.Redelegation; +import com.binance.dex.api.client.domain.stake.UnBondingDelegation; +import com.binance.dex.api.client.domain.stake.Validator; import com.binance.dex.api.client.domain.stake.sidechain.*; import com.binance.dex.api.client.encoding.message.*; import com.binance.dex.api.client.encoding.message.sidechain.SideChainIds; @@ -174,7 +178,7 @@ public void testSideChainUnbond() throws IOException, NoSuchAlgorithmException { @Test public void testGetSideChainValidator() throws IOException { - SideChainValidator validator = nodeClient.getSideChainValidator(SideChainIds.RIALTO, jackValidator); + Validator validator = nodeClient.getSideChainValidator(SideChainIds.RIALTO, jackValidator); if (validator != null){ Assert.assertNotNull(validator.getOperatorAddr()); } @@ -182,13 +186,13 @@ public void testGetSideChainValidator() throws IOException { @Test public void testGetSideChainTopValidators() throws IOException { - List validators = nodeClient.getSideChainTopValidators(SideChainIds.RIALTO, 5); + List validators = nodeClient.getSideChainTopValidators(SideChainIds.RIALTO, 5); Assert.assertNotNull(validators); } @Test public void testGetSideChainDelegation() throws IOException { - SideChainDelegation delegation = nodeClient.getSideChainDelegation(SideChainIds.RIALTO, wallet.getAddress(), roseValidator); + Delegation delegation = nodeClient.getSideChainDelegation(SideChainIds.RIALTO, wallet.getAddress(), roseValidator); if (delegation != null) { Assert.assertNotNull(delegation.getDelegation()); Assert.assertNotNull(delegation.getBalance()); @@ -197,13 +201,13 @@ public void testGetSideChainDelegation() throws IOException { @Test public void testGetSideChainDelegations() throws IOException { - List delegations = nodeClient.getSideChainDelegations(SideChainIds.RIALTO, wallet.getAddress()); + List delegations = nodeClient.getSideChainDelegations(SideChainIds.RIALTO, wallet.getAddress()); Assert.assertNotNull(delegations); } @Test public void getSideChainRedelegation() throws IOException { - SideChainRedelegation redelegation = nodeClient.getSideChainRedelegation(SideChainIds.RIALTO, wallet.getAddress(), jackValidator, roseValidator); + Redelegation redelegation = nodeClient.getSideChainRedelegation(SideChainIds.RIALTO, wallet.getAddress(), jackValidator, roseValidator); if (redelegation != null) { Assert.assertNotNull(redelegation.getDelegatorAddress()); } @@ -211,7 +215,7 @@ public void getSideChainRedelegation() throws IOException { @Test public void getSideChainRedelegations() throws IOException { - List redelegations = nodeClient.getSideChainRedelegations(SideChainIds.RIALTO, wallet.getAddress()); + List redelegations = nodeClient.getSideChainRedelegations(SideChainIds.RIALTO, wallet.getAddress()); Assert.assertNotNull(redelegations); } @@ -237,7 +241,7 @@ public void testGetSideChainUnBondingDelegationsByValidator() throws IOException @Test public void testGetSideChainRedelegationsByValidator() throws IOException { - List redelegations = nodeClient.getSideChainRedelegationsByValidator(SideChainIds.RIALTO, jackValidator); + List redelegations = nodeClient.getSideChainRedelegationsByValidator(SideChainIds.RIALTO, jackValidator); Assert.assertNotNull(redelegations); } From 7bb4e7bf45af57631863c37e22cf03c3b12cf080 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 4 Oct 2022 23:51:49 +0000 Subject: [PATCH 43/52] Bump protobuf-java from 3.6.1 to 3.16.3 Bumps [protobuf-java](https://github.com/protocolbuffers/protobuf) from 3.6.1 to 3.16.3. - [Release notes](https://github.com/protocolbuffers/protobuf/releases) - [Changelog](https://github.com/protocolbuffers/protobuf/blob/main/generate_changelog.py) - [Commits](https://github.com/protocolbuffers/protobuf/compare/v3.6.1...v3.16.3) --- updated-dependencies: - dependency-name: com.google.protobuf:protobuf-java dependency-type: direct:production ... Signed-off-by: dependabot[bot] --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index cd8fe01..12eefb0 100644 --- a/pom.xml +++ b/pom.xml @@ -42,7 +42,7 @@ com.google.protobuf protobuf-java - 3.6.1 + 3.16.3 io.grpc From b06613225360da94733405ce3b8aea91ab532a8a Mon Sep 17 00:00:00 2001 From: forcodedancing Date: Tue, 13 Dec 2022 11:33:34 +0800 Subject: [PATCH 44/52] bep159: add new transactions and the related converters --- pom.xml | 2 +- .../dex/api/client/TransactionConverter.java | 182 +++++++++++++++++- .../api/client/domain/broadcast/TxType.java | 7 +- .../client/encoding/message/MessageType.java | 9 +- .../TransactionConverterFactory.java | 15 ++ .../impl/FBeaconChainDelegateConverter.java | 39 ++++ .../impl/FBeaconChainRedelegateConverter.java | 32 +++ .../impl/FBeaconChainUndelegateConverter.java | 39 ++++ .../FCreateBeaconChainValidatorConverter.java | 22 +++ .../FEditBeaconChainValidatorConverter.java | 21 ++ 10 files changed, 364 insertions(+), 4 deletions(-) create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FBeaconChainDelegateConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FBeaconChainRedelegateConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FBeaconChainUndelegateConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FCreateBeaconChainValidatorConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FEditBeaconChainValidatorConverter.java diff --git a/pom.xml b/pom.xml index cd8fe01..bdde64f 100644 --- a/pom.xml +++ b/pom.xml @@ -5,7 +5,7 @@ com.binance.dex.api binance-dex-api-client - 1.1.3 + 1.1.4 diff --git a/src/main/java/com/binance/dex/api/client/TransactionConverter.java b/src/main/java/com/binance/dex/api/client/TransactionConverter.java index c4aa533..e90d920 100644 --- a/src/main/java/com/binance/dex/api/client/TransactionConverter.java +++ b/src/main/java/com/binance/dex/api/client/TransactionConverter.java @@ -32,14 +32,15 @@ import com.binance.dex.api.client.domain.slash.SideChainUnJail; import com.binance.dex.api.client.domain.stake.Commission; import com.binance.dex.api.client.domain.stake.Description; +import com.binance.dex.api.client.domain.stake.beaconchain.*; import com.binance.dex.api.client.domain.stake.sidechain.*; import com.binance.dex.api.client.encoding.ByteUtil; import com.binance.dex.api.client.encoding.Crypto; -import com.binance.dex.api.client.encoding.EncodeUtils; import com.binance.dex.api.client.encoding.amino.Amino; import com.binance.dex.api.client.encoding.message.InputOutput; import com.binance.dex.api.client.encoding.message.MessageType; import com.binance.dex.api.client.encoding.message.Token; +import com.binance.dex.api.client.encoding.message.beaconchain.transaction.*; import com.binance.dex.api.client.encoding.message.bridge.BindMsgMessage; import com.binance.dex.api.client.encoding.message.bridge.ClaimMsgMessage; import com.binance.dex.api.client.encoding.message.bridge.TransferOutMsgMessage; @@ -234,6 +235,16 @@ public Transaction convert(byte[] bytes) { return convertMiniTokenSetURI(bytes); case MiniTokenList: return convertMiniTokenList(bytes); + case CreateBeaconChainValidator: + return convertCreateBeaconChainValidator(bytes); + case EditBeaconChainValidator: + return convertEditBeaconChainValidator(bytes); + case BeaconChainDelegate: + return convertBeaconChainDelegate(bytes); + case BeaconChainRedelegate: + return convertBeaconChainRedelegate(bytes); + case BeaconChainUndelegate: + return convertBeaconChainUndelegate(bytes); } return null; } catch (Exception e) { @@ -241,6 +252,175 @@ public Transaction convert(byte[] bytes) { } } + private Transaction convertBeaconChainUndelegate(byte[] value) throws IOException { + byte[] raw = ByteUtil.cut(value, 4); + BeaconChainUndelegateMessage message = new BeaconChainUndelegateMessage(); + amino.decodeBare(raw, message); + + BeaconChainUndelegate unBond = new BeaconChainUndelegate(); + + if (message.getDelegatorAddress() != null && message.getDelegatorAddress().getRaw() != null) { + unBond.setDelegatorAddress(Crypto.encodeAddress(hrp, message.getDelegatorAddress().getRaw())); + } + + if (message.getValidatorAddress() != null && message.getValidatorAddress().getRaw() != null) { + unBond.setValidatorAddress(Crypto.encodeAddress(valHrp, message.getValidatorAddress().getRaw())); + } + + Token amount = new Token(); + if (message.getAmount() != null) { + amount.setAmount(message.getAmount().getAmount()); + amount.setDenom(message.getAmount().getDenom()); + } + unBond.setAmount(amount); + + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.BEACONCHAIN_UNDELEGATE); + transaction.setRealTx(unBond); + + return transaction; + } + + private Transaction convertBeaconChainRedelegate(byte[] value) throws IOException { + byte[] raw = ByteUtil.cut(value, 4); + BeaconChainRedelegateMessage message = new BeaconChainRedelegateMessage(); + amino.decodeBare(raw, message); + + BeaconChainRedelegate redelegate = new BeaconChainRedelegate(); + if (message.getDelegatorAddress() != null && message.getDelegatorAddress().getRaw() != null) { + redelegate.setDelegatorAddress(Crypto.encodeAddress(hrp, message.getDelegatorAddress().getRaw())); + } + + if (message.getSrcValidatorAddress() != null && message.getSrcValidatorAddress().getRaw() != null) { + redelegate.setSrcValidatorAddress(Crypto.encodeAddress(valHrp, message.getSrcValidatorAddress().getRaw())); + } + + if (message.getDstValidatorAddress() != null && message.getDstValidatorAddress().getRaw() != null) { + redelegate.setDstValidatorAddress(Crypto.encodeAddress(valHrp, message.getDstValidatorAddress().getRaw())); + } + + Token amount = new Token(); + if (message.getAmount() != null) { + amount.setAmount(message.getAmount().getAmount()); + amount.setDenom(message.getAmount().getDenom()); + } + redelegate.setAmount(amount); + + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.BEACONCHAIN_REDELEGATE); + transaction.setRealTx(redelegate); + + return transaction; + } + + private Transaction convertBeaconChainDelegate(byte[] value) throws IOException { + byte[] raw = ByteUtil.cut(value, 4); + BeaconChainDelegateMessage message = new BeaconChainDelegateMessage(); + amino.decodeBare(raw, message); + + BeaconChainDelegate beaconChainDelegate = new BeaconChainDelegate(); + if (message.getDelegatorAddress() != null && message.getDelegatorAddress().getRaw() != null) { + beaconChainDelegate.setDelegatorAddress(Crypto.encodeAddress(hrp, message.getDelegatorAddress().getRaw())); + } + + if (message.getValidatorAddress() != null && message.getValidatorAddress().getRaw() != null) { + beaconChainDelegate.setValidatorAddress(Crypto.encodeAddress(valHrp, message.getValidatorAddress().getRaw())); + } + + Token token = new Token(); + if (message.getDelegation() != null) { + token.setDenom(message.getDelegation().getDenom()); + token.setAmount(message.getDelegation().getAmount()); + } + beaconChainDelegate.setDelegation(token); + + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.BEACONCHAIN_DELEGATE); + transaction.setRealTx(beaconChainDelegate); + + return transaction; + } + + private Transaction convertEditBeaconChainValidator(byte[] value) throws IOException { + byte[] raw = ByteUtil.cut(value, 4); + EditBeaconChainValidatorMessage message = new EditBeaconChainValidatorMessage(); + amino.decodeBare(raw, message); + + EditBeaconChainValidator editBeaconChainValidator = new EditBeaconChainValidator(); + + Description description = new Description(); + if (message.getDescription() != null) { + description.setMoniker(message.getDescription().getMoniker()); + description.setDetails(message.getDescription().getDetails()); + description.setIdentity(message.getDescription().getIdentity()); + description.setWebsite(message.getDescription().getWebsite()); + } + editBeaconChainValidator.setDescription(description); + + if (message.getValidatorOperatorAddress() != null && message.getValidatorOperatorAddress().getRaw() != null) { + editBeaconChainValidator.setValidatorAddress(Crypto.encodeAddress(valHrp, message.getValidatorOperatorAddress().getRaw())); + } + + if (message.getCommissionRate() != null) { + editBeaconChainValidator.setCommissionRate(message.getCommissionRate().getValue()); + } + + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.EDIT_BEACONCHAIN_VALIDATOR); + transaction.setRealTx(editBeaconChainValidator); + + return transaction; + } + + private Transaction convertCreateBeaconChainValidator(byte[] value) throws IOException { + byte[] raw = ByteUtil.cut(value, 4); + CreateBeaconChainValidatorMessage message = new CreateBeaconChainValidatorMessage(); + amino.decodeBare(raw, message); + + CreateBeaconChainValidator createBeaconChainValidator = new CreateBeaconChainValidator(); + + Description description = new Description(); + if (message.getDescription() != null) { + description.setMoniker(message.getDescription().getMoniker()); + description.setDetails(message.getDescription().getDetails()); + description.setIdentity(message.getDescription().getIdentity()); + description.setWebsite(message.getDescription().getWebsite()); + } + createBeaconChainValidator.setDescription(description); + + Commission commission = new Commission(); + if (message.getCommission() != null) { + try { + commission.setRate(message.getCommission().getRate().getValue()); + commission.setMaxRate(message.getCommission().getMaxRate().getValue()); + commission.setMaxChangeRate(message.getCommission().getMaxChangeRate().getValue()); + } catch (NullPointerException e) { + //ignore + } + } + createBeaconChainValidator.setCommission(commission); + + if (message.getDelegatorAddr() != null && message.getDelegatorAddr().getRaw() != null) { + createBeaconChainValidator.setDelegatorAddr(Crypto.encodeAddress(hrp, message.getDelegatorAddr().getRaw())); + } + + if (message.getValidatorOperatorAddr() != null && message.getValidatorOperatorAddr().getRaw() != null) { + createBeaconChainValidator.setValidatorAddr(Crypto.encodeAddress(valHrp, message.getValidatorOperatorAddr().getRaw())); + } + + Token delegation = new Token(); + if (message.getDelegation() != null) { + delegation.setAmount(message.getDelegation().getAmount()); + delegation.setDenom(message.getDelegation().getDenom()); + } + createBeaconChainValidator.setDelegation(delegation); + + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.CREATE_BEACONCHAIN_VALIDATOR); + transaction.setRealTx(createBeaconChainValidator); + return transaction; + } + private Transaction convertTransferTokenOwnership(byte[] value) throws IOException { byte[] raw = ByteUtil.cut(value, 4); TransferTokenOwnershipMsg msg = TransferTokenOwnershipMsg.parseFrom(raw); diff --git a/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java b/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java index d63a67c..64f9918 100644 --- a/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java +++ b/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java @@ -41,5 +41,10 @@ public enum TxType { TINY_TOKEN_ISSUE, MINI_TOKEN_ISSUE, MINI_TOKEN_SET_URI, - MINI_TOKEN_LIST + MINI_TOKEN_LIST, + CREATE_BEACONCHAIN_VALIDATOR, + EDIT_BEACONCHAIN_VALIDATOR, + BEACONCHAIN_DELEGATE, + BEACONCHAIN_REDELEGATE, + BEACONCHAIN_UNDELEGATE } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java b/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java index bafa81e..47a8684 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java @@ -53,7 +53,14 @@ public enum MessageType { TinyTokenIssue("ED2832D4"), MiniTokenIssue("A3F16C41"), MiniTokenSetURI("7B1D34E7"), - MiniTokenList("4C264019"); + MiniTokenList("4C264019"), + + // open staking + CreateBeaconChainValidator("E9FB7335"), + EditBeaconChainValidator("C2E8BCCD"), + BeaconChainDelegate("921D2E4E"), + BeaconChainRedelegate("47A5ED9C"), + BeaconChainUndelegate("5C80810D"); private byte[] typePrefixBytes; diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/TransactionConverterFactory.java b/src/main/java/com/binance/dex/api/client/utils/converter/TransactionConverterFactory.java index b9b390f..a188b7a 100644 --- a/src/main/java/com/binance/dex/api/client/utils/converter/TransactionConverterFactory.java +++ b/src/main/java/com/binance/dex/api/client/utils/converter/TransactionConverterFactory.java @@ -138,6 +138,21 @@ public class TransactionConverterFactory { FUnfreezeConverter unfreezeConverter = new FUnfreezeConverter(); converterMap.put(unfreezeConverter.getType(), unfreezeConverter); + FCreateBeaconChainValidatorConverter createValConverter = new FCreateBeaconChainValidatorConverter(); + converterMap.put(createValConverter.getType(), createValConverter); + + FEditBeaconChainValidatorConverter editValConverter = new FEditBeaconChainValidatorConverter(); + converterMap.put(editValConverter.getType(), editValConverter); + + FBeaconChainDelegateConverter delegateConverter = new FBeaconChainDelegateConverter(); + converterMap.put(delegateConverter.getType(), delegateConverter); + + FBeaconChainRedelegateConverter redelegateConverter = new FBeaconChainRedelegateConverter(); + converterMap.put(redelegateConverter.getType(), redelegateConverter); + + FBeaconChainUndelegateConverter undelegateConverter = new FBeaconChainUndelegateConverter(); + converterMap.put(undelegateConverter.getType(), undelegateConverter); + FVoteConverter voteConverter = new FVoteConverter(); converterMap.put(voteConverter.getType(), voteConverter); } diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FBeaconChainDelegateConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FBeaconChainDelegateConverter.java new file mode 100644 index 0000000..6fa25f8 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FBeaconChainDelegateConverter.java @@ -0,0 +1,39 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.domain.stake.beaconchain.BeaconChainDelegate; +import com.binance.dex.api.client.utils.converter.JsonUtil; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.Token; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + +import java.util.Map; + + +public class FBeaconChainDelegateConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.BEACONCHAIN_DELEGATE; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setValue(NumberUtil.longToBigDecimalString(transactionV2.getAmount())); + + Map map = JsonUtil.fromJson(transactionV2.getData(), Map.class); + if (transaction.getValue() == null || transaction.getTxAsset() == null) { + Token token = getToken(map, "amount"); + transaction.setTxAsset(token.getDenom()); + transaction.setValue(NumberUtil.longToBigDecimalString(token.getAmount())); + } + + map.put("delegatorAddress", map.get("delegatorAddr")); + map.put("validatorAddress", map.get("validatorAddr")); + map.remove("delegatorAddr"); + map.remove("validatorAddr"); + transaction.setData(JsonUtil.toJson(map)); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FBeaconChainRedelegateConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FBeaconChainRedelegateConverter.java new file mode 100644 index 0000000..19441d0 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FBeaconChainRedelegateConverter.java @@ -0,0 +1,32 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.domain.stake.beaconchain.BeaconChainRedelegate; +import com.binance.dex.api.client.utils.converter.JsonUtil; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.Token; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + +import java.util.Map; + +public class FBeaconChainRedelegateConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.BEACONCHAIN_REDELEGATE; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setValue(NumberUtil.longToBigDecimalString(transactionV2.getAmount())); + + Map map = JsonUtil.fromJson(transactionV2.getData(), Map.class); + if (transaction.getValue() == null || transaction.getTxAsset() == null) { + Token token = getToken(map, "amount"); + transaction.setTxAsset(token.getDenom()); + transaction.setValue(NumberUtil.longToBigDecimalString(token.getAmount())); + } + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FBeaconChainUndelegateConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FBeaconChainUndelegateConverter.java new file mode 100644 index 0000000..79b49b4 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FBeaconChainUndelegateConverter.java @@ -0,0 +1,39 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.domain.stake.beaconchain.BeaconChainUndelegate; +import com.binance.dex.api.client.utils.converter.JsonUtil; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.Token; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + +import java.util.Map; + + +public class FBeaconChainUndelegateConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.BEACONCHAIN_UNDELEGATE; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setValue(NumberUtil.longToBigDecimalString(transactionV2.getAmount())); + + Map map = JsonUtil.fromJson(transactionV2.getData(), Map.class); + if (transaction.getValue() == null || transaction.getTxAsset() == null) { + Token token = getToken(map, "amount"); + transaction.setTxAsset(token.getDenom()); + transaction.setValue(NumberUtil.longToBigDecimalString(token.getAmount())); + } + + map.put("delegatorAddress", map.get("delegatorAddr")); + map.put("validatorAddress", map.get("validatorAddr")); + map.remove("delegatorAddr"); + map.remove("validatorAddr"); + transaction.setData(JsonUtil.toJson(map)); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FCreateBeaconChainValidatorConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FCreateBeaconChainValidatorConverter.java new file mode 100644 index 0000000..2d67d23 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FCreateBeaconChainValidatorConverter.java @@ -0,0 +1,22 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.domain.stake.beaconchain.CreateBeaconChainValidator; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + + +public class FCreateBeaconChainValidatorConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.CREATE_BEACONCHAIN_VALIDATOR; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setValue(NumberUtil.longToBigDecimalString(transactionV2.getAmount())); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FEditBeaconChainValidatorConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FEditBeaconChainValidatorConverter.java new file mode 100644 index 0000000..8be17a0 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FEditBeaconChainValidatorConverter.java @@ -0,0 +1,21 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.domain.stake.beaconchain.EditBeaconChainValidator; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + + +public class FEditBeaconChainValidatorConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.EDIT_BEACONCHAIN_VALIDATOR; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + return; + } +} From c9f9eb6605d2d83fdcde718fb046181c80488e6a Mon Sep 17 00:00:00 2001 From: WayToFuture Date: Thu, 5 Jan 2023 22:45:08 +0800 Subject: [PATCH 45/52] transaction: add support of unjail message (#141) --- pom.xml | 2 +- .../dex/api/client/TransactionConverter.java | 16 ++++++++++++++ .../api/client/domain/broadcast/TxType.java | 3 ++- .../dex/api/client/domain/slash/UnJail.java | 10 +++++++++ .../client/encoding/message/MessageType.java | 3 ++- .../api/client/utils/converter/TxType.java | 8 ++++++- .../converter/impl/FIssueTokenConverter.java | 2 +- .../impl/FMiniTokenIssueConverter.java | 2 +- .../impl/FTinyTokenIssueConverter.java | 2 +- .../converter/impl/FUnJailConverter.java | 21 +++++++++++++++++++ src/main/proto/dex.proto | 5 +++++ 11 files changed, 67 insertions(+), 7 deletions(-) create mode 100644 src/main/java/com/binance/dex/api/client/domain/slash/UnJail.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FUnJailConverter.java diff --git a/pom.xml b/pom.xml index bdde64f..57e52f4 100644 --- a/pom.xml +++ b/pom.xml @@ -5,7 +5,7 @@ com.binance.dex.api binance-dex-api-client - 1.1.4 + 1.1.5 diff --git a/src/main/java/com/binance/dex/api/client/TransactionConverter.java b/src/main/java/com/binance/dex/api/client/TransactionConverter.java index e90d920..8754fee 100644 --- a/src/main/java/com/binance/dex/api/client/TransactionConverter.java +++ b/src/main/java/com/binance/dex/api/client/TransactionConverter.java @@ -30,6 +30,7 @@ import com.binance.dex.api.client.domain.oracle.ClaimMsg; import com.binance.dex.api.client.domain.slash.BscSubmitEvidence; import com.binance.dex.api.client.domain.slash.SideChainUnJail; +import com.binance.dex.api.client.domain.slash.UnJail; import com.binance.dex.api.client.domain.stake.Commission; import com.binance.dex.api.client.domain.stake.Description; import com.binance.dex.api.client.domain.stake.beaconchain.*; @@ -245,6 +246,8 @@ public Transaction convert(byte[] bytes) { return convertBeaconChainRedelegate(bytes); case BeaconChainUndelegate: return convertBeaconChainUndelegate(bytes); + case UnJail: + return convertUnJail(bytes); } return null; } catch (Exception e) { @@ -421,6 +424,19 @@ private Transaction convertCreateBeaconChainValidator(byte[] value) throws IOExc return transaction; } + private Transaction convertUnJail(byte[] value) throws IOException { + byte[] raw = ByteUtil.cut(value, 4); + UnJailMsg message = UnJailMsg.parseFrom(raw); + + UnJail unJail = new UnJail(); + unJail.setValidatorAddr(Crypto.encodeAddress(valHrp, message.getAddress().toByteArray())); + + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.UNJAIL); + transaction.setRealTx(unJail); + return transaction; + } + private Transaction convertTransferTokenOwnership(byte[] value) throws IOException { byte[] raw = ByteUtil.cut(value, 4); TransferTokenOwnershipMsg msg = TransferTokenOwnershipMsg.parseFrom(raw); diff --git a/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java b/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java index 64f9918..8b78ed3 100644 --- a/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java +++ b/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java @@ -46,5 +46,6 @@ public enum TxType { EDIT_BEACONCHAIN_VALIDATOR, BEACONCHAIN_DELEGATE, BEACONCHAIN_REDELEGATE, - BEACONCHAIN_UNDELEGATE + BEACONCHAIN_UNDELEGATE, + UNJAIL } diff --git a/src/main/java/com/binance/dex/api/client/domain/slash/UnJail.java b/src/main/java/com/binance/dex/api/client/domain/slash/UnJail.java new file mode 100644 index 0000000..0e75671 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/slash/UnJail.java @@ -0,0 +1,10 @@ +package com.binance.dex.api.client.domain.slash; + +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +public class UnJail { + private String validatorAddr; +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java b/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java index 47a8684..2a84a8e 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java @@ -60,7 +60,8 @@ public enum MessageType { EditBeaconChainValidator("C2E8BCCD"), BeaconChainDelegate("921D2E4E"), BeaconChainRedelegate("47A5ED9C"), - BeaconChainUndelegate("5C80810D"); + BeaconChainUndelegate("5C80810D"), + UnJail("543AEC70"); private byte[] typePrefixBytes; diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/TxType.java b/src/main/java/com/binance/dex/api/client/utils/converter/TxType.java index 5e4fddb..508765a 100644 --- a/src/main/java/com/binance/dex/api/client/utils/converter/TxType.java +++ b/src/main/java/com/binance/dex/api/client/utils/converter/TxType.java @@ -44,7 +44,13 @@ public enum TxType { TINY_TOKEN_ISSUE(com.binance.dex.api.client.domain.broadcast.TxType.TINY_TOKEN_ISSUE), MINI_TOKEN_ISSUE(com.binance.dex.api.client.domain.broadcast.TxType.MINI_TOKEN_ISSUE), MINI_TOKEN_LIST(com.binance.dex.api.client.domain.broadcast.TxType.MINI_TOKEN_LIST), - MINI_TOKEN_SET_URI(com.binance.dex.api.client.domain.broadcast.TxType.MINI_TOKEN_SET_URI); + MINI_TOKEN_SET_URI(com.binance.dex.api.client.domain.broadcast.TxType.MINI_TOKEN_SET_URI), + CREATE_BEACONCHAIN_VALIDATOR(com.binance.dex.api.client.domain.broadcast.TxType.CREATE_BEACONCHAIN_VALIDATOR), + EDIT_BEACONCHAIN_VALIDATOR(com.binance.dex.api.client.domain.broadcast.TxType.EDIT_BEACONCHAIN_VALIDATOR), + BEACONCHAIN_DELEGATE(com.binance.dex.api.client.domain.broadcast.TxType.BEACONCHAIN_DELEGATE), + BEACONCHAIN_REDELEGATE(com.binance.dex.api.client.domain.broadcast.TxType.BEACONCHAIN_REDELEGATE), + BEACONCHAIN_UNDELEGATE(com.binance.dex.api.client.domain.broadcast.TxType.BEACONCHAIN_UNDELEGATE), + UNJAIL(com.binance.dex.api.client.domain.broadcast.TxType.UNJAIL); private com.binance.dex.api.client.domain.broadcast.TxType code; diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FIssueTokenConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FIssueTokenConverter.java index edf0601..34636cf 100644 --- a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FIssueTokenConverter.java +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FIssueTokenConverter.java @@ -21,7 +21,7 @@ public TxType getType() { @Override public void doConvert(TransactionV2 transactionV2, Transaction transaction) { Map map = JsonUtil.fromJson(transactionV2.getData(), Map.class); - Long totalSupply = (Long) map.get("totalSupply"); + Long totalSupply = Long.valueOf(map.get("totalSupply").toString()); transaction.setValue(NumberUtil.longToBigDecimalString(totalSupply)); transaction.setData(null); } diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FMiniTokenIssueConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FMiniTokenIssueConverter.java index 8dde7ae..0616b76 100644 --- a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FMiniTokenIssueConverter.java +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FMiniTokenIssueConverter.java @@ -21,7 +21,7 @@ public TxType getType() { @Override public void doConvert(TransactionV2 transactionV2, Transaction transaction) { Map map = JsonUtil.fromJson(transactionV2.getData(), Map.class); - Long totalSupply = (Long) map.get("totalSupply"); + Long totalSupply = Long.valueOf(map.get("totalSupply").toString()); transaction.setValue(NumberUtil.longToBigDecimalString(totalSupply)); transaction.setData(null); diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FTinyTokenIssueConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FTinyTokenIssueConverter.java index 29de6ba..adc2690 100644 --- a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FTinyTokenIssueConverter.java +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FTinyTokenIssueConverter.java @@ -21,7 +21,7 @@ public TxType getType() { @Override public void doConvert(TransactionV2 transactionV2, Transaction transaction) { Map map = JsonUtil.fromJson(transactionV2.getData(), Map.class); - Long totalSupply = (Long) map.get("totalSupply"); + Long totalSupply = Long.valueOf(map.get("totalSupply").toString()); transaction.setValue(NumberUtil.longToBigDecimalString(totalSupply)); transaction.setData(null); diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FUnJailConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FUnJailConverter.java new file mode 100644 index 0000000..334a5b5 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FUnJailConverter.java @@ -0,0 +1,21 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.domain.slash.UnJail; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + + +public class FUnJailConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.UNJAIL; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + return; + } +} diff --git a/src/main/proto/dex.proto b/src/main/proto/dex.proto index 6e5fe01..99de24f 100644 --- a/src/main/proto/dex.proto +++ b/src/main/proto/dex.proto @@ -469,4 +469,9 @@ message TransferTokenOwnershipMsg { bytes from = 1; string symbol = 2; bytes new_owner = 3; +} + +message UnJailMsg { + // 543AEC70 + bytes address = 1; } \ No newline at end of file From a84afa164e20bfc84c37ff293e737c2a9a3eeaf4 Mon Sep 17 00:00:00 2001 From: zjubfd <296179868@qq.com> Date: Fri, 6 Jan 2023 10:53:04 +0800 Subject: [PATCH 46/52] docs: update the readme to latest (#142) --- README.md | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-) diff --git a/README.md b/README.md index 27d9b98..b5c282c 100644 --- a/README.md +++ b/README.md @@ -1,15 +1,12 @@ -# Binance Chain Java SDK +# BNB Beacon Chain Java SDK -The Binance Chain Java SDK works as a lightweight Java library for interacting with the [Binance Chain](https://docs.bnbchain.org/docs/beaconchain/develop/api-reference/dex-api/paths). It provides a complete API coverage, and supports synchronous and asynchronous requests. It includes the following core components: +The BNB Beacon Chain Java SDK works as a lightweight Java library for interacting with the [BNB Beacon Chain](https://docs.bnbchain.org/docs/beaconchain/develop/api-reference/dex-api/paths). It provides a complete API coverage, and supports synchronous and asynchronous requests. It includes the following core components: * **[crypto](https://github.com/bnb-chain/java-sdk/blob/master/src/main/java/com/binance/dex/api/client/encoding/Crypto.java)** - core cryptographic functions. * **[amino encoding](https://github.com/bnb-chain/java-sdk/blob/master/src/main/java/com/binance/dex/api/client/encoding)** - [amino](https://docs.bnbchain.org/docs/beaconchain/learn/encoding/encoding/#amino) (protobuf-like) encoding and decoding of transactions. -* **[client](https://github.com/bnb-chain/java-sdk/tree/master/src/main/java/com/binance/dex/api/client/impl)** - implementations of API rest client, supporting synchronous and asynchronous access to Binance Chain's REST APIs. +* **[client](https://github.com/bnb-chain/java-sdk/tree/master/src/main/java/com/binance/dex/api/client/impl)** - implementations of API rest client, supporting synchronous and asynchronous access to BNB Beacon Chain's REST APIs. * **[wallet](https://github.com/bnb-chain/java-sdk/blob/master/src/main/java/com/binance/dex/api/client/Wallet.java)** - management of accounts, including seed and encrypted mnemonic generation. -## Disclaimer -**This branch is under active development, all subject to potential future change without notification and not ready for production use. The code and security audit have not been fully completed and not ready for any bug bounty.** - # How to get 1. Add the JitPack repository to your project's `pom.xml`: @@ -40,12 +37,12 @@ More details please refer to https://github.com/xolstice/protobuf-maven-plugin # API -For examples, please check the [wiki](https://github.com/bnb-chain/java-sdk/wiki). +For examples, please check the [wiki](https://github.com/bnb-chain/java-sdk/wiki/API). # Testing -All new code changes should be covered with unit tests. You can see the existing test cases here: https://github.com/bnb-chain/java-sdk/tree/master/src/test/java/com/binance/dex/api/client/encoding +All new code changes should be covered with unit tests. You can see the existing test cases [here](https://github.com/bnb-chain/java-sdk/tree/master/src/test/java/com/binance/dex/api/client/encoding). # Contributing -Contributions to the Binance Chain Java SDK are welcome. Please ensure that you have tested the changes with a local client and have added unit test coverage for your code. +Contributions to the BNB Beacon Chain Java SDK are welcome. Please ensure that you have tested the changes with a local client and have added unit test coverage for your code. From 5a68dc24a86350914aa5d4db336f551bdb3fa8f9 Mon Sep 17 00:00:00 2001 From: forcodedancing Date: Tue, 25 Apr 2023 10:29:31 +0800 Subject: [PATCH 47/52] feat: support new transaction types for fast finality (#143) --- pom.xml | 2 +- .../dex/api/client/TransactionConverter.java | 108 +++++++++++ .../api/client/domain/broadcast/TxType.java | 4 +- .../CreateSideChainValidatorWithVoteAddr.java | 116 ++++++++++++ .../EditSideChainValidatorWithVoteAddr.java | 81 ++++++++ .../client/encoding/message/MessageType.java | 6 +- ...SideChainValidatorWithVoteAddrMessage.java | 179 ++++++++++++++++++ ...SideChainValidatorWithVoteAddrMessage.java | 143 ++++++++++++++ .../api/client/utils/converter/TxType.java | 4 +- ...deChainValidatorWithVoteAddrConverter.java | 23 +++ ...deChainValidatorWithVoteAddrConverter.java | 22 +++ .../dex/api/client/encoding/AminoTest.java | 147 ++++++++++++-- .../BeaconChainStakingNodeExample.java | 21 +- .../client/examples/NodeClientExample.java | 35 ++-- 14 files changed, 848 insertions(+), 43 deletions(-) create mode 100644 src/main/java/com/binance/dex/api/client/domain/stake/sidechain/CreateSideChainValidatorWithVoteAddr.java create mode 100644 src/main/java/com/binance/dex/api/client/domain/stake/sidechain/EditSideChainValidatorWithVoteAddr.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/CreateSideChainValidatorWithVoteAddrMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/EditSideChainValidatorWithVoteAddrMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FCreateSideChainValidatorWithVoteAddrConverter.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FEditSideChainValidatorWithVoteAddrConverter.java diff --git a/pom.xml b/pom.xml index 57e52f4..89021f3 100644 --- a/pom.xml +++ b/pom.xml @@ -5,7 +5,7 @@ com.binance.dex.api binance-dex-api-client - 1.1.5 + 1.1.6 diff --git a/src/main/java/com/binance/dex/api/client/TransactionConverter.java b/src/main/java/com/binance/dex/api/client/TransactionConverter.java index 8754fee..f54e2d0 100644 --- a/src/main/java/com/binance/dex/api/client/TransactionConverter.java +++ b/src/main/java/com/binance/dex/api/client/TransactionConverter.java @@ -248,6 +248,10 @@ public Transaction convert(byte[] bytes) { return convertBeaconChainUndelegate(bytes); case UnJail: return convertUnJail(bytes); + case CreateSideChainValidatorWithVoteAddr: + return convertCreateSideChainValidatorWithVoteAddr(bytes); + case EditSideChainValidatorWithVoteAddr: + return convertEditSideChainValidatorWithVoteAddr(bytes); } return null; } catch (Exception e) { @@ -1325,4 +1329,108 @@ private Transaction convertMiniTokenList(byte[] value) throws InvalidProtocolBuf transaction.setRealTx(listing); return transaction; } + + private Transaction convertCreateSideChainValidatorWithVoteAddr(byte[] value) throws IOException { + byte[] raw = ByteUtil.cut(value, 4); + CreateSideChainValidatorWithVoteAddrMessage message = new CreateSideChainValidatorWithVoteAddrMessage(); + amino.decodeBare(raw, message); + + CreateSideChainValidatorWithVoteAddr createSideChainValidator = new CreateSideChainValidatorWithVoteAddr(); + + Description description = new Description(); + if (message.getDescription() != null) { + description.setMoniker(message.getDescription().getMoniker()); + description.setDetails(message.getDescription().getDetails()); + description.setIdentity(message.getDescription().getIdentity()); + description.setWebsite(message.getDescription().getWebsite()); + } + createSideChainValidator.setDescription(description); + + Commission commission = new Commission(); + if (message.getCommission() != null) { + try { + commission.setRate(message.getCommission().getRate().getValue()); + commission.setMaxRate(message.getCommission().getMaxRate().getValue()); + commission.setMaxChangeRate(message.getCommission().getMaxChangeRate().getValue()); + } catch (NullPointerException e) { + //ignore + } + } + createSideChainValidator.setCommission(commission); + + if (message.getDelegatorAddr() != null && message.getDelegatorAddr().getRaw() != null) { + createSideChainValidator.setDelegatorAddr(Crypto.encodeAddress(hrp, message.getDelegatorAddr().getRaw())); + } + + if (message.getValidatorOperatorAddr() != null && message.getValidatorOperatorAddr().getRaw() != null) { + createSideChainValidator.setValidatorAddr(Crypto.encodeAddress(valHrp, message.getValidatorOperatorAddr().getRaw())); + } + + Token delegation = new Token(); + if (message.getDelegation() != null) { + delegation.setAmount(message.getDelegation().getAmount()); + delegation.setDenom(message.getDelegation().getDenom()); + } + createSideChainValidator.setDelegation(delegation); + + createSideChainValidator.setSideChainId(message.getSideChainId()); + + if (message.getSideConsAddr() != null) { + createSideChainValidator.setSideConsAddr("0x" + Hex.toHexString(message.getSideConsAddr())); + } + + if (message.getSideFeeAddr() != null) { + createSideChainValidator.setSideFeeAddr("0x" + Hex.toHexString(message.getSideFeeAddr())); + } + + if (message.getSideVoteAddr() != null) { + createSideChainValidator.setSideVoteAddr("0x" + Hex.toHexString(message.getSideVoteAddr())); + } + + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.CREATE_SIDECHAIN_VALIDATOR_WITH_VOTE_ADDR); + transaction.setRealTx(createSideChainValidator); + return transaction; + } + + private Transaction convertEditSideChainValidatorWithVoteAddr(byte[] value) throws IOException { + byte[] raw = ByteUtil.cut(value, 4); + EditSideChainValidatorWithVoteAddrMessage message = new EditSideChainValidatorWithVoteAddrMessage(); + amino.decodeBare(raw, message); + + EditSideChainValidatorWithVoteAddr editSideChainValidator = new EditSideChainValidatorWithVoteAddr(); + + Description description = new Description(); + if (message.getDescription() != null) { + description.setMoniker(message.getDescription().getMoniker()); + description.setDetails(message.getDescription().getDetails()); + description.setIdentity(message.getDescription().getIdentity()); + description.setWebsite(message.getDescription().getWebsite()); + } + editSideChainValidator.setDescription(description); + + if (message.getValidatorOperatorAddress() != null && message.getValidatorOperatorAddress().getRaw() != null) { + editSideChainValidator.setValidatorAddress(Crypto.encodeAddress(valHrp, message.getValidatorOperatorAddress().getRaw())); + } + + if (message.getCommissionRate() != null) { + editSideChainValidator.setCommissionRate(message.getCommissionRate().getValue()); + } + + editSideChainValidator.setSideChainId(message.getSideChainId()); + + if (message.getSideFeeAddr() != null) { + editSideChainValidator.setSideFeeAddr("0x" + Hex.toHexString(message.getSideFeeAddr())); + } + + if (message.getSideVoteAddr() != null) { + editSideChainValidator.setSideVoteAddr("0x" + Hex.toHexString(message.getSideVoteAddr())); + } + + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.EDIT_SIDECHAIN_VALIDATOR_WITH_VOTE_ADDR); + transaction.setRealTx(editSideChainValidator); + + return transaction; + } } diff --git a/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java b/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java index 8b78ed3..925b15b 100644 --- a/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java +++ b/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java @@ -47,5 +47,7 @@ public enum TxType { BEACONCHAIN_DELEGATE, BEACONCHAIN_REDELEGATE, BEACONCHAIN_UNDELEGATE, - UNJAIL + UNJAIL, + CREATE_SIDECHAIN_VALIDATOR_WITH_VOTE_ADDR, + EDIT_SIDECHAIN_VALIDATOR_WITH_VOTE_ADDR, } diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/CreateSideChainValidatorWithVoteAddr.java b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/CreateSideChainValidatorWithVoteAddr.java new file mode 100644 index 0000000..68979f2 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/CreateSideChainValidatorWithVoteAddr.java @@ -0,0 +1,116 @@ +package com.binance.dex.api.client.domain.stake.sidechain; + +import com.binance.dex.api.client.domain.stake.Commission; +import com.binance.dex.api.client.domain.stake.Description; +import com.binance.dex.api.client.encoding.message.Token; + +public class CreateSideChainValidatorWithVoteAddr { + + private Description description; + + private Commission commission; + + private String delegatorAddr; + + private String validatorAddr; + + private Token delegation; + + private String sideChainId; + + private String sideConsAddr; + + private String sideFeeAddr; + + private String sideVoteAddr; + + public CreateSideChainValidatorWithVoteAddr() { + } + + public Description getDescription() { + return description; + } + + public void setDescription(Description description) { + this.description = description; + } + + public Commission getCommission() { + return commission; + } + + public void setCommission(Commission commission) { + this.commission = commission; + } + + public String getDelegatorAddr() { + return delegatorAddr; + } + + public void setDelegatorAddr(String delegatorAddr) { + this.delegatorAddr = delegatorAddr; + } + + public Token getDelegation() { + return delegation; + } + + public void setDelegation(Token delegation) { + this.delegation = delegation; + } + + public String getSideChainId() { + return sideChainId; + } + + public void setSideChainId(String sideChainId) { + this.sideChainId = sideChainId; + } + + public String getSideConsAddr() { + return sideConsAddr; + } + + public void setSideConsAddr(String sideConsAddr) { + this.sideConsAddr = sideConsAddr; + } + + public String getSideFeeAddr() { + return sideFeeAddr; + } + + public void setSideFeeAddr(String sideFeeAddr) { + this.sideFeeAddr = sideFeeAddr; + } + + public String getValidatorAddr() { + return validatorAddr; + } + + public void setValidatorAddr(String validatorAddr) { + this.validatorAddr = validatorAddr; + } + + public String getSideVoteAddr() { + return sideVoteAddr; + } + + public void setSideVoteAddr(String sideVoteAddr) { + this.sideVoteAddr = sideVoteAddr; + } + + @Override + public String toString() { + return "CreateSideChainValidator{" + '\n' + + "description=" + description + '\n' + + ", commission=" + commission + '\n' + + ", delegatorAddr='" + delegatorAddr + '\'' + '\n' + + ", validatorAddr='" + validatorAddr + '\'' + '\n' + + ", delegation=" + delegation + '\n' + + ", sideChainId='" + sideChainId + '\'' + '\n' + + ", sideConsAddr='" + sideConsAddr + '\'' + '\n' + + ", sideFeeAddr='" + sideFeeAddr + '\'' + '\n' + + ", sideVoteAddr='" + sideVoteAddr + '\'' + '\n' + + '}'; + } +} diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/EditSideChainValidatorWithVoteAddr.java b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/EditSideChainValidatorWithVoteAddr.java new file mode 100644 index 0000000..44ea59f --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/EditSideChainValidatorWithVoteAddr.java @@ -0,0 +1,81 @@ +package com.binance.dex.api.client.domain.stake.sidechain; + +import com.binance.dex.api.client.domain.stake.Description; + +public class EditSideChainValidatorWithVoteAddr { + + private Description description; + + private String validatorAddress; + + private long commissionRate; + + private String sideChainId; + + private String sideFeeAddr; + + private String sideVoteAddr; + + public EditSideChainValidatorWithVoteAddr() { + } + + public Description getDescription() { + return description; + } + + public void setDescription(Description description) { + this.description = description; + } + + public String getValidatorAddress() { + return validatorAddress; + } + + public void setValidatorAddress(String validatorAddress) { + this.validatorAddress = validatorAddress; + } + + public long getCommissionRate() { + return commissionRate; + } + + public void setCommissionRate(long commissionRate) { + this.commissionRate = commissionRate; + } + + public String getSideChainId() { + return sideChainId; + } + + public void setSideChainId(String sideChainId) { + this.sideChainId = sideChainId; + } + + public String getSideFeeAddr() { + return sideFeeAddr; + } + + public void setSideFeeAddr(String sideFeeAddr) { + this.sideFeeAddr = sideFeeAddr; + } + + public String getSideVoteAddr() { + return sideVoteAddr; + } + + public void setSideVoteAddr(String sideVoteAddr) { + this.sideVoteAddr = sideVoteAddr; + } + + @Override + public String toString() { + return "EditSideChainValidator{" + + "description=" + description + "\n" + + ", validatorAddress='" + validatorAddress + '\'' + "\n" + + ", commissionRate=" + commissionRate + "\n" + + ", sideChainId='" + sideChainId + '\'' + "\n" + + ", sideFeeAddr='" + sideFeeAddr + '\'' + "\n" + + ", sideVoteAddr='" + sideVoteAddr + '\'' + "\n" + + '}'; + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java b/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java index 2a84a8e..813900c 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java @@ -61,7 +61,11 @@ public enum MessageType { BeaconChainDelegate("921D2E4E"), BeaconChainRedelegate("47A5ED9C"), BeaconChainUndelegate("5C80810D"), - UnJail("543AEC70"); + UnJail("543AEC70"), + + // fast finality + CreateSideChainValidatorWithVoteAddr("A0032998"), + EditSideChainValidatorWithVoteAddr("852FDADD"); private byte[] typePrefixBytes; diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/CreateSideChainValidatorWithVoteAddrMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/CreateSideChainValidatorWithVoteAddrMessage.java new file mode 100644 index 0000000..d2ca130 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/CreateSideChainValidatorWithVoteAddrMessage.java @@ -0,0 +1,179 @@ +package com.binance.dex.api.client.encoding.message.sidechain.transaction; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.encoding.message.common.CoinValueStr; +import com.binance.dex.api.client.encoding.message.sidechain.value.CommissionMsgValue; +import com.binance.dex.api.client.encoding.message.sidechain.value.DescriptionValue; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import org.apache.commons.lang3.StringUtils; + +import java.util.ArrayList; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class CreateSideChainValidatorWithVoteAddrMessage implements BinanceDexTransactionMessage, AminoSerializable { + + @JsonProperty(value = "description") + private DescriptionValue description = new DescriptionValue(); + + @JsonProperty(value = "commission") + private CommissionMsgValue commission = new CommissionMsgValue(); + + @JsonProperty(value = "delegator_address") + private Bech32AddressValue delegatorAddr; + + @JsonProperty(value = "validator_address") + private Bech32AddressValue validatorOperatorAddr; + + @JsonProperty(value = "delegation") + private CoinValueStr delegation; + + @JsonProperty(value = "side_chain_id") + private String sideChainId; + + @JsonProperty(value = "side_cons_addr") + private byte[] sideConsAddr; + + @JsonProperty(value = "side_fee_addr") + private byte[] sideFeeAddr; + + @JsonProperty(value = "side_vote_addr") + private byte[] sideVoteAddr; + + @Override + public boolean useAminoJson() { + return true; + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + description = ((DescriptionValue) value); + break; + case 2: + commission = ((CommissionMsgValue) value); + break; + case 3: + delegatorAddr = ((Bech32AddressValue) value); + break; + case 4: + validatorOperatorAddr = ((Bech32AddressValue) value); + break; + case 5: + delegation = ((CoinValueStr) value); + break; + case 6: + sideChainId = ((String) value); + break; + case 7: + sideConsAddr = ((byte[]) value); + break; + case 8: + sideFeeAddr = ((byte[]) value); + break; + case 9: + sideVoteAddr = ((byte[]) value); + break; + default: + break; + } + } + + @Override + public AminoSerializable newAminoMessage() { + return new CreateSideChainValidatorWithVoteAddrMessage(); + } + + @Override + public ArrayList> IterateFields() { + ArrayList> fields = new ArrayList<>(); + fields.add(new AminoField<>(DescriptionValue.class, description, description == null)); + fields.add(new AminoField<>(CommissionMsgValue.class, commission, commission == null)); + fields.add(new AminoField<>(Bech32AddressValue.class, delegatorAddr, delegatorAddr == null || delegatorAddr.isDefaultOrEmpty())); + fields.add(new AminoField<>(Bech32AddressValue.class, validatorOperatorAddr, validatorOperatorAddr == null || validatorOperatorAddr.isDefaultOrEmpty())); + fields.add(new AminoField<>(CoinValueStr.class, delegation, delegation == null)); + fields.add(new AminoField<>(String.class, sideChainId, StringUtils.isEmpty(sideChainId))); + fields.add(new AminoField<>(byte[].class, sideConsAddr, sideConsAddr == null || sideConsAddr.length == 0)); + fields.add(new AminoField<>(byte[].class, sideFeeAddr, sideFeeAddr == null || sideFeeAddr.length == 0)); + fields.add(new AminoField<>(byte[].class, sideVoteAddr, sideVoteAddr == null || sideVoteAddr.length == 0)); + return fields; + } + + public DescriptionValue getDescription() { + return description; + } + + public void setDescription(DescriptionValue description) { + this.description = description; + } + + public CommissionMsgValue getCommission() { + return commission; + } + + public void setCommission(CommissionMsgValue commission) { + this.commission = commission; + } + + public Bech32AddressValue getDelegatorAddr() { + return delegatorAddr; + } + + public void setDelegatorAddr(Bech32AddressValue delegatorAddr) { + this.delegatorAddr = delegatorAddr; + } + + public Bech32AddressValue getValidatorOperatorAddr() { + return validatorOperatorAddr; + } + + public void setValidatorOperatorAddr(Bech32AddressValue validatorOperatorAddr) { + this.validatorOperatorAddr = validatorOperatorAddr; + } + + public CoinValueStr getDelegation() { + return delegation; + } + + public void setDelegation(CoinValueStr delegation) { + this.delegation = delegation; + } + + public String getSideChainId() { + return sideChainId; + } + + public void setSideChainId(String sideChainId) { + this.sideChainId = sideChainId; + } + + public byte[] getSideConsAddr() { + return sideConsAddr; + } + + public void setSideConsAddr(byte[] sideConsAddr) { + this.sideConsAddr = sideConsAddr; + } + + public byte[] getSideFeeAddr() { + return sideFeeAddr; + } + + public void setSideFeeAddr(byte[] sideFeeAddr) { + this.sideFeeAddr = sideFeeAddr; + } + + public byte[] getSideVoteAddr() { + return sideVoteAddr; + } + + public void setSideVoteAddr(byte[] sideVoteAddr) { + this.sideVoteAddr = sideVoteAddr; + } +} \ No newline at end of file diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/EditSideChainValidatorWithVoteAddrMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/EditSideChainValidatorWithVoteAddrMessage.java new file mode 100644 index 0000000..c139f58 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/EditSideChainValidatorWithVoteAddrMessage.java @@ -0,0 +1,143 @@ +package com.binance.dex.api.client.encoding.message.sidechain.transaction; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.encoding.message.common.Dec; +import com.binance.dex.api.client.encoding.message.sidechain.value.DescriptionValue; +import com.binance.dex.api.client.encoding.serializer.DecToStringSerializer; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import org.apache.commons.lang3.StringUtils; + +import java.util.ArrayList; + +/** + * @author Fitz.Lu + **/ +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class EditSideChainValidatorWithVoteAddrMessage implements BinanceDexTransactionMessage, AminoSerializable { + + @JsonProperty(value = "description") + private DescriptionValue description; + + @JsonProperty(value = "address") + private Bech32AddressValue validatorOperatorAddress; + + @JsonProperty(value = "commission_rate") + @JsonSerialize(using = DecToStringSerializer.class) + private Dec commissionRate; + + @JsonProperty(value = "side_chain_id") + private String sideChainId; + + @JsonProperty(value = "side_fee_addr") + private byte[] sideFeeAddr; + + @JsonProperty(value = "side_vote_addr") + private byte[] sideVoteAddr; + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + description = ((DescriptionValue) value); + break; + case 2: + validatorOperatorAddress = ((Bech32AddressValue) value); + break; + case 3: + commissionRate = ((Dec) value); + break; + case 4: + sideChainId = ((String) value); + break; + case 5: + sideFeeAddr = ((byte[]) value); + break; + case 6: + sideVoteAddr = ((byte[]) value); + break; + default: + break; + } + } + + public EditSideChainValidatorWithVoteAddrMessage() { + } + + public DescriptionValue getDescription() { + return description; + } + + public void setDescription(DescriptionValue description) { + this.description = description; + } + + public Bech32AddressValue getValidatorOperatorAddress() { + return validatorOperatorAddress; + } + + public void setValidatorOperatorAddress(Bech32AddressValue validatorOperatorAddress) { + this.validatorOperatorAddress = validatorOperatorAddress; + } + + public Dec getCommissionRate() { + return commissionRate; + } + + public void setCommissionRate(Dec commissionRate) { + this.commissionRate = commissionRate; + } + + public String getSideChainId() { + return sideChainId; + } + + public void setSideChainId(String sideChainId) { + this.sideChainId = sideChainId; + } + + public byte[] getSideFeeAddr() { + return sideFeeAddr; + } + + public void setSideFeeAddr(byte[] sideFeeAddr) { + this.sideFeeAddr = sideFeeAddr; + } + + public byte[] getSideVoteAddr() { + return sideVoteAddr; + } + + public void setSideVoteAddr(byte[] sideVoteAddr) { + this.sideVoteAddr = sideVoteAddr; + } + + @Override + public boolean useAminoJson() { + return true; + } + + @Override + public AminoSerializable newAminoMessage() { + return new EditSideChainValidatorWithVoteAddrMessage(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(DescriptionValue.class, description, description == null) + .addField(Bech32AddressValue.class, validatorOperatorAddress, validatorOperatorAddress == null || validatorOperatorAddress.isDefaultOrEmpty()) + .addField(Dec.class, commissionRate, commissionRate == null || commissionRate.isDefaultOrEmpty()) + .addField(String.class, sideChainId, StringUtils.isEmpty(sideChainId)) + .addField(byte[].class, sideFeeAddr, sideFeeAddr == null || sideFeeAddr.length == 0) + .addField(byte[].class, sideVoteAddr, sideVoteAddr == null || sideVoteAddr.length == 0) + .build(); + } + +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/TxType.java b/src/main/java/com/binance/dex/api/client/utils/converter/TxType.java index 508765a..38d67f7 100644 --- a/src/main/java/com/binance/dex/api/client/utils/converter/TxType.java +++ b/src/main/java/com/binance/dex/api/client/utils/converter/TxType.java @@ -50,7 +50,9 @@ public enum TxType { BEACONCHAIN_DELEGATE(com.binance.dex.api.client.domain.broadcast.TxType.BEACONCHAIN_DELEGATE), BEACONCHAIN_REDELEGATE(com.binance.dex.api.client.domain.broadcast.TxType.BEACONCHAIN_REDELEGATE), BEACONCHAIN_UNDELEGATE(com.binance.dex.api.client.domain.broadcast.TxType.BEACONCHAIN_UNDELEGATE), - UNJAIL(com.binance.dex.api.client.domain.broadcast.TxType.UNJAIL); + UNJAIL(com.binance.dex.api.client.domain.broadcast.TxType.UNJAIL), + CREATE_SIDECHAIN_VALIDATOR_WITH_VOTE_ADDR(com.binance.dex.api.client.domain.broadcast.TxType.CREATE_SIDECHAIN_VALIDATOR_WITH_VOTE_ADDR), + EDIT_SIDECHAIN_VALIDATOR_WITH_VOTE_ADDR(com.binance.dex.api.client.domain.broadcast.TxType.EDIT_SIDECHAIN_VALIDATOR_WITH_VOTE_ADDR); private com.binance.dex.api.client.domain.broadcast.TxType code; diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FCreateSideChainValidatorWithVoteAddrConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FCreateSideChainValidatorWithVoteAddrConverter.java new file mode 100644 index 0000000..666e0e1 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FCreateSideChainValidatorWithVoteAddrConverter.java @@ -0,0 +1,23 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.domain.stake.sidechain.CreateSideChainValidator; +import com.binance.dex.api.client.domain.stake.sidechain.CreateSideChainValidatorWithVoteAddr; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + + +public class FCreateSideChainValidatorWithVoteAddrConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.CREATE_SIDECHAIN_VALIDATOR_WITH_VOTE_ADDR; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setValue(NumberUtil.longToBigDecimalString(transactionV2.getAmount())); + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FEditSideChainValidatorWithVoteAddrConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FEditSideChainValidatorWithVoteAddrConverter.java new file mode 100644 index 0000000..33e0099 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FEditSideChainValidatorWithVoteAddrConverter.java @@ -0,0 +1,22 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.domain.stake.sidechain.EditSideChainValidator; +import com.binance.dex.api.client.domain.stake.sidechain.EditSideChainValidatorWithVoteAddr; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + + +public class FEditSideChainValidatorWithVoteAddrConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.EDIT_SIDECHAIN_VALIDATOR_WITH_VOTE_ADDR; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + return; + } +} diff --git a/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java b/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java index 80eb68a..baad17a 100644 --- a/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java +++ b/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java @@ -58,7 +58,7 @@ public static byte[] hexStringToByteArray(String s) { byte[] data = new byte[len / 2]; for (int i = 0; i < len; i += 2) { data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4) - + Character.digit(s.charAt(i+1), 16)); + + Character.digit(s.charAt(i + 1), 16)); } return data; } @@ -242,10 +242,86 @@ public void testDecodeSideChainUnBond() throws IOException { Assert.assertNotNull(tx.getRealTx()); } - EditSideChainValidatorMessage convert(EditSideChainValidator editSideChainValidator){ + @Test + public void testCreateSideChainValidatorWithVoteAddr() throws IOException { + CreateSideChainValidatorWithVoteAddr createSideChainValidator = new CreateSideChainValidatorWithVoteAddr(); + + //create and set description + Description validatorDescription = new Description(); + validatorDescription.setMoniker("custom-moniker"); + validatorDescription.setIdentity("ide"); + validatorDescription.setWebsite("https://www.website.com"); + validatorDescription.setDetails("This is a side-chain validator"); + + createSideChainValidator.setDescription(validatorDescription); + + //create and set commission + Commission commission = new Commission(); + commission.setRate(5L); + commission.setMaxRate(100L); + commission.setMaxChangeRate(5L); + + createSideChainValidator.setCommission(commission); + + //set delegator address, here use self address + createSideChainValidator.setDelegatorAddr(wallet.getAddress()); + + createSideChainValidator.setValidatorAddr(wallet.getAddress()); + + //set delegation token, here use 1000000 BNB + Token delegationToken = new Token(); + delegationToken.setDenom("BNB"); + delegationToken.setAmount(10000000000L); + createSideChainValidator.setDelegation(delegationToken); + + //set side-chain id + createSideChainValidator.setSideChainId("bsc"); + + //set side-chain validator cons address + createSideChainValidator.setSideConsAddr("0xd1B22dCC24C55f4d728E7aaA5c9b5a22e1512C08"); + + //set side-chain validator fee address + createSideChainValidator.setSideFeeAddr("0x9fB29AAc15b9A4B7F17c3385939b007540f4d791"); + + createSideChainValidator.setSideVoteAddr("0x11FfBAC7fA17f5c9084a15C8f0f15dAe845A5712"); + + byte[] msg = amino.encode(convert(createSideChainValidator), MessageType.CreateSideChainValidatorWithVoteAddr.getTypePrefixBytes(), false); + + Transaction tx = transactionConverter.convert(msg); + Assert.assertNotNull(tx.getRealTx()); + } + + @Test + public void testDecodeEditSideChainValidatorWithVoteAddr() throws IOException { + EditSideChainValidatorWithVoteAddr editSideChainValidator = new EditSideChainValidatorWithVoteAddr(); + + //set new description if needed + Description description = new Description(); + description.setMoniker("new Moniker"); + editSideChainValidator.setDescription(description); + + editSideChainValidator.setValidatorAddress(wallet.getAddress()); + + //set new rate if needed + editSideChainValidator.setCommissionRate(1L); + + //set new fee address if needed + editSideChainValidator.setSideFeeAddr("0xd1B22dCC24C55f4d728E7aaA5c9b5a22e1512C08"); + + editSideChainValidator.setSideChainId("bsc"); + + editSideChainValidator.setSideVoteAddr("0x11FfBAC7fA17f5c9084a15C8f0f15dAe845A5712"); + + byte[] msg = amino.encode(convert(editSideChainValidator), MessageType.EditSideChainValidatorWithVoteAddr.getTypePrefixBytes(), false); + + Transaction tx = transactionConverter.convert(msg); + Assert.assertNotNull(tx.getRealTx()); + } + + EditSideChainValidatorMessage convert(EditSideChainValidator editSideChainValidator) { EditSideChainValidatorMessage message = new EditSideChainValidatorMessage(); - if (editSideChainValidator.getDescription() != null){ + if (editSideChainValidator.getDescription() != null) { message.setDescription(convert(editSideChainValidator.getDescription())); } @@ -258,20 +334,20 @@ EditSideChainValidatorMessage convert(EditSideChainValidator editSideChainValida return message; } - CreateSideChainValidatorMessage convert(CreateSideChainValidator createSideChainValidator){ + CreateSideChainValidatorMessage convert(CreateSideChainValidator createSideChainValidator) { CreateSideChainValidatorMessage message = new CreateSideChainValidatorMessage(); - if (createSideChainValidator.getDescription() != null){ + if (createSideChainValidator.getDescription() != null) { message.setDescription(convert(createSideChainValidator.getDescription())); } - if (createSideChainValidator.getCommission() != null){ + if (createSideChainValidator.getCommission() != null) { message.setCommission(convert(createSideChainValidator.getCommission())); } message.setDelegatorAddr(Bech32AddressValue.fromBech32String(createSideChainValidator.getDelegatorAddr())); message.setValidatorOperatorAddr(Bech32AddressValue.fromBech32String(createSideChainValidator.getValidatorAddr())); - if (createSideChainValidator.getDelegation() != null){ + if (createSideChainValidator.getDelegation() != null) { message.setDelegation(convert(createSideChainValidator.getDelegation())); } @@ -281,7 +357,7 @@ CreateSideChainValidatorMessage convert(CreateSideChainValidator createSideChain return message; } - private DescriptionValue convert(Description description){ + private DescriptionValue convert(Description description) { DescriptionValue value = new DescriptionValue(); value.setMoniker(description.getMoniker()); value.setDetails(description.getDetails()); @@ -290,7 +366,7 @@ private DescriptionValue convert(Description description){ return value; } - private CommissionMsgValue convert(Commission commission){ + private CommissionMsgValue convert(Commission commission) { CommissionMsgValue value = new CommissionMsgValue(); value.setRate(Dec.newInstance(commission.getRate())); value.setMaxRate(Dec.newInstance(commission.getMaxRate())); @@ -298,14 +374,14 @@ private CommissionMsgValue convert(Commission commission){ return value; } - private CoinValueStr convert(Token token){ + private CoinValueStr convert(Token token) { CoinValueStr value = new CoinValueStr(); value.setDenom(token.getDenom()); value.setAmount(token.getAmount()); return value; } - private SideChainDelegateMessage convert(SideChainDelegate sideChainDelegate){ + private SideChainDelegateMessage convert(SideChainDelegate sideChainDelegate) { SideChainDelegateMessage message = new SideChainDelegateMessage(); message.setDelegatorAddress(Bech32AddressValue.fromBech32String(sideChainDelegate.getDelegatorAddress())); message.setValidatorAddress(Bech32AddressValue.fromBech32String(sideChainDelegate.getValidatorAddress())); @@ -318,7 +394,7 @@ private SideChainDelegateMessage convert(SideChainDelegate sideChainDelegate){ return message; } - private SideChainRedelegateMessage convert(SideChainRedelegate redelegate){ + private SideChainRedelegateMessage convert(SideChainRedelegate redelegate) { SideChainRedelegateMessage message = new SideChainRedelegateMessage(); message.setDelegatorAddress(Bech32AddressValue.fromBech32String(redelegate.getDelegatorAddress())); message.setSrcValidatorAddress(Bech32AddressValue.fromBech32String(redelegate.getSrcValidatorAddress())); @@ -330,7 +406,7 @@ private SideChainRedelegateMessage convert(SideChainRedelegate redelegate){ return message; } - private SideChainUndelegateMessage convert(SideChainUnBond unBond){ + private SideChainUndelegateMessage convert(SideChainUnBond unBond) { SideChainUndelegateMessage message = new SideChainUndelegateMessage(); message.setDelegatorAddress(Bech32AddressValue.fromBech32String(unBond.getDelegatorAddress())); message.setValidatorAddress(Bech32AddressValue.fromBech32String(unBond.getValidatorAddress())); @@ -341,9 +417,50 @@ private SideChainUndelegateMessage convert(SideChainUnBond unBond){ return message; } - private byte[] decodeHexAddress(String address){ + CreateSideChainValidatorWithVoteAddrMessage convert(CreateSideChainValidatorWithVoteAddr createSideChainValidator) { + CreateSideChainValidatorWithVoteAddrMessage message = new CreateSideChainValidatorWithVoteAddrMessage(); + + if (createSideChainValidator.getDescription() != null) { + message.setDescription(convert(createSideChainValidator.getDescription())); + } + if (createSideChainValidator.getCommission() != null) { + message.setCommission(convert(createSideChainValidator.getCommission())); + } + + message.setDelegatorAddr(Bech32AddressValue.fromBech32String(createSideChainValidator.getDelegatorAddr())); + message.setValidatorOperatorAddr(Bech32AddressValue.fromBech32String(createSideChainValidator.getValidatorAddr())); + + if (createSideChainValidator.getDelegation() != null) { + message.setDelegation(convert(createSideChainValidator.getDelegation())); + } + + message.setSideChainId(createSideChainValidator.getSideChainId()); + message.setSideConsAddr(decodeHexAddress(createSideChainValidator.getSideConsAddr())); + message.setSideFeeAddr(decodeHexAddress(createSideChainValidator.getSideFeeAddr())); + message.setSideVoteAddr(decodeHexAddress(createSideChainValidator.getSideVoteAddr())); + return message; + } + + EditSideChainValidatorWithVoteAddrMessage convert(EditSideChainValidatorWithVoteAddr editSideChainValidator) { + EditSideChainValidatorWithVoteAddrMessage message = new EditSideChainValidatorWithVoteAddrMessage(); + + if (editSideChainValidator.getDescription() != null) { + message.setDescription(convert(editSideChainValidator.getDescription())); + } + + message.setValidatorOperatorAddress(Bech32AddressValue.fromBech32String(editSideChainValidator.getValidatorAddress())); + + message.setCommissionRate(Dec.newInstance(editSideChainValidator.getCommissionRate())); + message.setSideChainId(editSideChainValidator.getSideChainId()); + message.setSideFeeAddr(decodeHexAddress(editSideChainValidator.getSideFeeAddr())); + message.setSideVoteAddr(decodeHexAddress(editSideChainValidator.getSideVoteAddr())); + + return message; + } + + private byte[] decodeHexAddress(String address) { String addr = address; - if (addr.startsWith("0x")){ + if (addr.startsWith("0x")) { addr = address.substring(2); } return Hex.decode(addr); diff --git a/src/test/java/com/binance/dex/api/client/examples/BeaconChainStakingNodeExample.java b/src/test/java/com/binance/dex/api/client/examples/BeaconChainStakingNodeExample.java index 4e2c8ac..5cf8deb 100644 --- a/src/test/java/com/binance/dex/api/client/examples/BeaconChainStakingNodeExample.java +++ b/src/test/java/com/binance/dex/api/client/examples/BeaconChainStakingNodeExample.java @@ -11,11 +11,8 @@ import com.binance.dex.api.client.domain.broadcast.Transfer; import com.binance.dex.api.client.domain.stake.*; import com.binance.dex.api.client.domain.stake.beaconchain.*; -import com.binance.dex.api.client.domain.stake.sidechain.CreateSideChainValidator; -import com.binance.dex.api.client.domain.stake.sidechain.EditSideChainValidator; import com.binance.dex.api.client.encoding.Crypto; import com.binance.dex.api.client.encoding.message.Token; -import com.binance.dex.api.client.encoding.message.sidechain.SideChainIds; import org.junit.Assert; import org.junit.Before; import org.junit.Test; @@ -39,7 +36,7 @@ public class BeaconChainStakingNodeExample { private BinanceDexEnvironment env; private Wallet wallet; - private List getMnemonicCodeWords(){ + private List getMnemonicCodeWords() { String mnemonicCodeWordStr = "bottom quick strong ranch section decide pepper broken oven demand coin run jacket curious business achieve mule bamboo remain vote kid rigid bench rubber"; List mnemonicCodeWords = new ArrayList(); String[] mnemonicCodeWordStrs = mnemonicCodeWordStr.split(" "); @@ -54,7 +51,7 @@ public void setup() { env = BinanceDexEnvironment.LOCAL_NET; nodeClient = BinanceDexApiClientFactory.newInstance().newNodeRpcClient(env.getNodeUrl() - ,env.getHrp(), env.getValHrp()); + , env.getHrp(), env.getValHrp()); try { wallet = Wallet.createWalletFromMnemonicCode(this.getMnemonicCodeWords(), env); } catch (IOException e) { @@ -210,10 +207,10 @@ public void testStaking() throws IOException, NoSuchAlgorithmException { logger.info(String.format("query validator: %s \n", validator)); Assert.assertNotNull("validator should not be nil", validator); Assert.assertEquals("validator address should be equal", validator.getFeeAddr(), validator0.getAddress()); - Assert.assertEquals("validator tokens should be 123e8", validator.getTokens(), 12300000000L); - Assert.assertEquals("validator description should be equal", validator.getDescription().getMoniker(), "node1"); - Assert.assertEquals("validator rate should be equal", validator.getCommission().getRate(), 1); - Assert.assertEquals("validator consensusPubKey should be equal", new String(validator.getConsPubKey()), consensusPubKey); + Assert.assertEquals("validator tokens should be 123e8", validator.getTokens(), 12300000000L); + Assert.assertEquals("validator description should be equal", validator.getDescription().getMoniker(), "node1"); + Assert.assertEquals("validator rate should be equal", validator.getCommission().getRate(), 1); + Assert.assertEquals("validator consensusPubKey should be equal", new String(validator.getConsPubKey()), consensusPubKey); // edit validator todo String consensusPubKey2 = genPubKey(); @@ -314,8 +311,6 @@ public void testStaking() throws IOException, NoSuchAlgorithmException { } - - public void createBeaconChainValidator(Wallet wallet, String pubKey) throws IOException, NoSuchAlgorithmException { CreateBeaconChainValidator createBeaconChainValidator = new CreateBeaconChainValidator(); @@ -440,8 +435,8 @@ public void beaconChainUndelegate(Wallet wallet, String validatorAddress, Long a * Create a transaction option for test * * @return TransactionOption - * */ - private TransactionOption createTransactionOptionForTest(){ + */ + private TransactionOption createTransactionOptionForTest() { return new TransactionOption("", 0, null); } diff --git a/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java b/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java index f6a4157..a5a33f2 100644 --- a/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java +++ b/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java @@ -1,6 +1,5 @@ package com.binance.dex.api.client.examples; - import com.binance.dex.api.client.BinanceDexApiClientFactory; import com.binance.dex.api.client.BinanceDexApiNodeClient; import com.binance.dex.api.client.BinanceDexEnvironment; @@ -28,7 +27,7 @@ public class NodeClientExample { @Before public void setup() { - binanceDexNodeApi = BinanceDexApiClientFactory.newInstance().newNodeRpcClient(BinanceDexEnvironment.TEST_NET.getNodeUrl(),BinanceDexEnvironment.TEST_NET.getHrp(), BinanceDexEnvironment.TEST_NET.getValHrp()); + binanceDexNodeApi = BinanceDexApiClientFactory.newInstance().newNodeRpcClient(BinanceDexEnvironment.LOCAL_NET.getNodeUrl(), BinanceDexEnvironment.LOCAL_NET.getHrp(), BinanceDexEnvironment.LOCAL_NET.getValHrp()); } @Test @@ -39,7 +38,7 @@ public void testAccount() { } @Test - public void testCommittedAccount(){ + public void testCommittedAccount() { String address = "tbnb16hywxpvvkaz6cecjz89mf2w0da3vfeg6z6yky2"; Account account = binanceDexNodeApi.getCommittedAccount(address); Assert.assertEquals(address, account.getAddress()); @@ -253,17 +252,17 @@ public void testGetBlockMetaByHash() { } @Test - public void testGetTokenInfoBySymbol(){ + public void testGetTokenInfoBySymbol() { Token token = binanceDexNodeApi.getTokenInfoBySymbol("BNB"); Assert.assertNotNull(token); - Assert.assertEquals("BNB",token.getSymbol()); + Assert.assertEquals("BNB", token.getSymbol()); } @Test - public void testGetMiniTokenInfoBySymbol(){ + public void testGetMiniTokenInfoBySymbol() { MiniToken token = binanceDexNodeApi.getMiniTokenInfoBySymbol("TTT-873M"); Assert.assertNotNull(token); - Assert.assertEquals("TTT-873M",token.getSymbol()); + Assert.assertEquals("TTT-873M", token.getSymbol()); } @Test @@ -281,14 +280,28 @@ public void testStakeValidator() { } @Test - public void testGetProposalById(){ + public void testGetProposalById() { Proposal proposal = binanceDexNodeApi.getProposalById("1"); - Assert.assertEquals("1",proposal.getValue().getProposalId()); + Assert.assertEquals("1", proposal.getValue().getProposalId()); } @Test - public void testGetSideProposalById(){ + public void testGetSideProposalById() { Proposal proposal = binanceDexNodeApi.getSideProposalById("4", "rialto"); - Assert.assertEquals("4",proposal.getValue().getProposalId()); + Assert.assertEquals("4", proposal.getValue().getProposalId()); + } + + @Test + public void testCreateSidechainValidatorWithVoteAddr() { + Transaction transaction = binanceDexNodeApi.getTransaction("0B660182B6E571A2BF9644624EA75890FC5C87F45759B4B0CC74BAA63B61501C"); + Assert.assertNotNull(transaction); + Assert.assertEquals(transaction.getTxType(), TxType.CREATE_SIDECHAIN_VALIDATOR_WITH_VOTE_ADDR); + } + + @Test + public void testEditSidechainValidatorWithVoteAddr() { + Transaction transaction = binanceDexNodeApi.getTransaction("037A67C45ADFEE6F978D1B02EEB18BAD6EE427C3BA55674B3F2C421E42E7D1DB"); + Assert.assertNotNull(transaction); + Assert.assertEquals(transaction.getTxType(), TxType.EDIT_SIDECHAIN_VALIDATOR_WITH_VOTE_ADDR); } } From 42b64c7cb0c017580e89badede807fc32e71ff69 Mon Sep 17 00:00:00 2001 From: randyahx <62416962+randyahx@users.noreply.github.com> Date: Wed, 5 Jul 2023 11:28:15 +0800 Subject: [PATCH 48/52] chore: bnb wording change (#144) --- LICENSE | 2 +- .../client/BinanceDexApiClientGenerator.java | 18 +++++++++--------- .../dex/api/client/BinanceDexApiError.java | 2 +- .../dex/api/client/BinanceDexApiException.java | 16 ++++++++-------- .../dex/api/client/BinanceDexConstants.java | 4 ++-- .../dex/api/client/BinanceDexEnvironment.java | 8 ++++---- .../dex/api/client/BinanceDexNodeApi.java | 2 +- .../dex/api/client/BinanceTransactionApi.java | 2 +- 8 files changed, 27 insertions(+), 27 deletions(-) diff --git a/LICENSE b/LICENSE index f48a48c..2b3b563 100644 --- a/LICENSE +++ b/LICENSE @@ -186,7 +186,7 @@ same "printed page" as the copyright notice for easier identification within third-party archives. - Copyright 2018-2019 Binance + Copyright 2018-2019 All BNB Chain Developers Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexApiClientGenerator.java b/src/main/java/com/binance/dex/api/client/BinanceDexApiClientGenerator.java index 87de40a..868bd12 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexApiClientGenerator.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexApiClientGenerator.java @@ -18,14 +18,14 @@ import java.lang.annotation.Annotation; import java.util.concurrent.TimeUnit; -public class BinanceDexApiClientGenerator { +public class BNBDexApiClientGenerator { private static final Converter.Factory converterFactory = JacksonConverterFactory.create(new ObjectMapper().registerModule(new JodaModule())); @SuppressWarnings("unchecked") - private static final Converter errorBodyConverter = - (Converter) converterFactory.responseBodyConverter( - BinanceDexApiError.class, new Annotation[0], null); + private static final Converter errorBodyConverter = + (Converter) converterFactory.responseBodyConverter( + BNBDexApiError.class, new Annotation[0], null); private static OkHttpClient sharedClient; static { @@ -78,21 +78,21 @@ public static T executeSync(Call call) { return response.body(); } else { try { - BinanceDexApiError apiError = getBinanceApiError(response); - throw new BinanceDexApiException(apiError); + BNBDexApiError apiError = getBNBApiError(response); + throw new BNBDexApiException(apiError); } catch (IOException e) { - throw new BinanceDexApiException(response.code(), response.toString()); + throw new BNBDexApiException(response.code(), response.toString()); } } } catch (IOException e) { - throw new BinanceDexApiException(e); + throw new BNBDexApiException(e); } } /** * Extracts and converts the response error body into an object. */ - public static BinanceDexApiError getBinanceApiError(Response response) throws IOException { + public static BNBDexApiError getBNBApiError(Response response) throws IOException { return errorBodyConverter.convert(response.errorBody()); } diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexApiError.java b/src/main/java/com/binance/dex/api/client/BinanceDexApiError.java index bc70d6a..b3c891a 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexApiError.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexApiError.java @@ -5,7 +5,7 @@ import org.apache.commons.lang3.builder.ToStringStyle; @JsonIgnoreProperties(ignoreUnknown = true) -public class BinanceDexApiError { +public class BNBDexApiError { private int code; private String message; diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexApiException.java b/src/main/java/com/binance/dex/api/client/BinanceDexApiException.java index 6dd7d41..83222b0 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexApiException.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexApiException.java @@ -1,30 +1,30 @@ package com.binance.dex.api.client; -public class BinanceDexApiException extends RuntimeException { +public class BNBDexApiException extends RuntimeException { private static final long serialVersionUID = 3788669840036201041L; - private BinanceDexApiError error; + private BNBDexApiError error; - public BinanceDexApiException(BinanceDexApiError error) { + public BNBDexApiException(BNBDexApiError error) { this.error = error; } - public BinanceDexApiException(Throwable cause) { + public BNBDexApiException(Throwable cause) { super(cause); } - public BinanceDexApiException(int code,String message){ - BinanceDexApiError apiError = new BinanceDexApiError(); + public BNBDexApiException(int code,String message){ + BNBDexApiError apiError = new BNBDexApiError(); apiError.setCode(code); apiError.setMessage(message); this.error = apiError; } - public BinanceDexApiException(String message, Throwable cause) { + public BNBDexApiException(String message, Throwable cause) { super(message, cause); } - public BinanceDexApiError getError() { + public BNBDexApiError getError() { return error; } diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexConstants.java b/src/main/java/com/binance/dex/api/client/BinanceDexConstants.java index 4cc752c..9f7b5cb 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexConstants.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexConstants.java @@ -7,14 +7,14 @@ public class BinanceDexConstants { /** * Identifier of this client. */ - public static final long BINANCE_DEX_API_CLIENT_JAVA_SOURCE = 0L; + public static final long BNB_DEX_API_CLIENT_JAVA_SOURCE = 0L; /** * Default ToStringStyle used by toString methods. * Override this to change the output format of the overridden toString methods. * - Example ToStringStyle.JSON_STYLE */ - public static final ToStringStyle BINANCE_DEX_TO_STRING_STYLE = ToStringStyle.SHORT_PREFIX_STYLE; + public static final ToStringStyle BNB_DEX_TO_STRING_STYLE = ToStringStyle.SHORT_PREFIX_STYLE; /** * HTTP Header to be used for API-KEY authentication. diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexEnvironment.java b/src/main/java/com/binance/dex/api/client/BinanceDexEnvironment.java index 4b165ef..245e8bb 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexEnvironment.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexEnvironment.java @@ -3,8 +3,8 @@ import org.apache.commons.lang3.builder.EqualsBuilder; import org.apache.commons.lang3.builder.HashCodeBuilder; -public class BinanceDexEnvironment { - public static final BinanceDexEnvironment PROD = new BinanceDexEnvironment( +public class BNBDexEnvironment { + public static final BNBDexEnvironment PROD = new BNBDexEnvironment( "https://dex.binance.org", "https://api.binance.org/bc/", "wss://dex.binance.org/api", @@ -13,7 +13,7 @@ public class BinanceDexEnvironment { "bnb", "bva" ); - public static final BinanceDexEnvironment TEST_NET = new BinanceDexEnvironment( + public static final BNBDexEnvironment TEST_NET = new BNBDexEnvironment( "https://testnet-dex.binance.org", "https://testnet-api.binance.org/bc/", "wss://testnet-dex.binance.org/api", @@ -23,7 +23,7 @@ public class BinanceDexEnvironment { "bva" ); - public static final BinanceDexEnvironment LOCAL_NET = new BinanceDexEnvironment( + public static final BNBDexEnvironment LOCAL_NET = new BNBDexEnvironment( "https://testnet-dex.binance.org", "https://testnet-api.binance.org/bc/", "wss://testnet-dex.binance.org/api", diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexNodeApi.java b/src/main/java/com/binance/dex/api/client/BinanceDexNodeApi.java index edab597..6b0ca77 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexNodeApi.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexNodeApi.java @@ -6,7 +6,7 @@ import retrofit2.http.GET; import retrofit2.http.Query; -public interface BinanceDexNodeApi { +public interface BNBDexNodeApi { @GET("/abci_query") Call> getAccount(@Query("path") String pathWithAddress); diff --git a/src/main/java/com/binance/dex/api/client/BinanceTransactionApi.java b/src/main/java/com/binance/dex/api/client/BinanceTransactionApi.java index 314d894..0199a8d 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceTransactionApi.java +++ b/src/main/java/com/binance/dex/api/client/BinanceTransactionApi.java @@ -6,7 +6,7 @@ import retrofit2.http.Path; import retrofit2.http.Query; -public interface BinanceTransactionApi { +public interface BNBTransactionApi { @GET("api/v1/txs") Call getTransactions(@Query(value = "startTime") Long startTime, @Query(value = "endTime") Long endTime, From 165d91277cad98d348faa8eee0e529f5f71f020c Mon Sep 17 00:00:00 2001 From: forcodedancing Date: Wed, 2 Aug 2023 14:39:06 +0800 Subject: [PATCH 49/52] Revert "chore: bnb wording change (#144)" This reverts commit 42b64c7cb0c017580e89badede807fc32e71ff69. --- LICENSE | 2 +- .../client/BinanceDexApiClientGenerator.java | 18 +++++++++--------- .../dex/api/client/BinanceDexApiError.java | 2 +- .../dex/api/client/BinanceDexApiException.java | 16 ++++++++-------- .../dex/api/client/BinanceDexConstants.java | 4 ++-- .../dex/api/client/BinanceDexEnvironment.java | 8 ++++---- .../dex/api/client/BinanceDexNodeApi.java | 2 +- .../dex/api/client/BinanceTransactionApi.java | 2 +- 8 files changed, 27 insertions(+), 27 deletions(-) diff --git a/LICENSE b/LICENSE index 2b3b563..f48a48c 100644 --- a/LICENSE +++ b/LICENSE @@ -186,7 +186,7 @@ same "printed page" as the copyright notice for easier identification within third-party archives. - Copyright 2018-2019 All BNB Chain Developers + Copyright 2018-2019 Binance Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexApiClientGenerator.java b/src/main/java/com/binance/dex/api/client/BinanceDexApiClientGenerator.java index 868bd12..87de40a 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexApiClientGenerator.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexApiClientGenerator.java @@ -18,14 +18,14 @@ import java.lang.annotation.Annotation; import java.util.concurrent.TimeUnit; -public class BNBDexApiClientGenerator { +public class BinanceDexApiClientGenerator { private static final Converter.Factory converterFactory = JacksonConverterFactory.create(new ObjectMapper().registerModule(new JodaModule())); @SuppressWarnings("unchecked") - private static final Converter errorBodyConverter = - (Converter) converterFactory.responseBodyConverter( - BNBDexApiError.class, new Annotation[0], null); + private static final Converter errorBodyConverter = + (Converter) converterFactory.responseBodyConverter( + BinanceDexApiError.class, new Annotation[0], null); private static OkHttpClient sharedClient; static { @@ -78,21 +78,21 @@ public static T executeSync(Call call) { return response.body(); } else { try { - BNBDexApiError apiError = getBNBApiError(response); - throw new BNBDexApiException(apiError); + BinanceDexApiError apiError = getBinanceApiError(response); + throw new BinanceDexApiException(apiError); } catch (IOException e) { - throw new BNBDexApiException(response.code(), response.toString()); + throw new BinanceDexApiException(response.code(), response.toString()); } } } catch (IOException e) { - throw new BNBDexApiException(e); + throw new BinanceDexApiException(e); } } /** * Extracts and converts the response error body into an object. */ - public static BNBDexApiError getBNBApiError(Response response) throws IOException { + public static BinanceDexApiError getBinanceApiError(Response response) throws IOException { return errorBodyConverter.convert(response.errorBody()); } diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexApiError.java b/src/main/java/com/binance/dex/api/client/BinanceDexApiError.java index b3c891a..bc70d6a 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexApiError.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexApiError.java @@ -5,7 +5,7 @@ import org.apache.commons.lang3.builder.ToStringStyle; @JsonIgnoreProperties(ignoreUnknown = true) -public class BNBDexApiError { +public class BinanceDexApiError { private int code; private String message; diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexApiException.java b/src/main/java/com/binance/dex/api/client/BinanceDexApiException.java index 83222b0..6dd7d41 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexApiException.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexApiException.java @@ -1,30 +1,30 @@ package com.binance.dex.api.client; -public class BNBDexApiException extends RuntimeException { +public class BinanceDexApiException extends RuntimeException { private static final long serialVersionUID = 3788669840036201041L; - private BNBDexApiError error; + private BinanceDexApiError error; - public BNBDexApiException(BNBDexApiError error) { + public BinanceDexApiException(BinanceDexApiError error) { this.error = error; } - public BNBDexApiException(Throwable cause) { + public BinanceDexApiException(Throwable cause) { super(cause); } - public BNBDexApiException(int code,String message){ - BNBDexApiError apiError = new BNBDexApiError(); + public BinanceDexApiException(int code,String message){ + BinanceDexApiError apiError = new BinanceDexApiError(); apiError.setCode(code); apiError.setMessage(message); this.error = apiError; } - public BNBDexApiException(String message, Throwable cause) { + public BinanceDexApiException(String message, Throwable cause) { super(message, cause); } - public BNBDexApiError getError() { + public BinanceDexApiError getError() { return error; } diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexConstants.java b/src/main/java/com/binance/dex/api/client/BinanceDexConstants.java index 9f7b5cb..4cc752c 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexConstants.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexConstants.java @@ -7,14 +7,14 @@ public class BinanceDexConstants { /** * Identifier of this client. */ - public static final long BNB_DEX_API_CLIENT_JAVA_SOURCE = 0L; + public static final long BINANCE_DEX_API_CLIENT_JAVA_SOURCE = 0L; /** * Default ToStringStyle used by toString methods. * Override this to change the output format of the overridden toString methods. * - Example ToStringStyle.JSON_STYLE */ - public static final ToStringStyle BNB_DEX_TO_STRING_STYLE = ToStringStyle.SHORT_PREFIX_STYLE; + public static final ToStringStyle BINANCE_DEX_TO_STRING_STYLE = ToStringStyle.SHORT_PREFIX_STYLE; /** * HTTP Header to be used for API-KEY authentication. diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexEnvironment.java b/src/main/java/com/binance/dex/api/client/BinanceDexEnvironment.java index 245e8bb..4b165ef 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexEnvironment.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexEnvironment.java @@ -3,8 +3,8 @@ import org.apache.commons.lang3.builder.EqualsBuilder; import org.apache.commons.lang3.builder.HashCodeBuilder; -public class BNBDexEnvironment { - public static final BNBDexEnvironment PROD = new BNBDexEnvironment( +public class BinanceDexEnvironment { + public static final BinanceDexEnvironment PROD = new BinanceDexEnvironment( "https://dex.binance.org", "https://api.binance.org/bc/", "wss://dex.binance.org/api", @@ -13,7 +13,7 @@ public class BNBDexEnvironment { "bnb", "bva" ); - public static final BNBDexEnvironment TEST_NET = new BNBDexEnvironment( + public static final BinanceDexEnvironment TEST_NET = new BinanceDexEnvironment( "https://testnet-dex.binance.org", "https://testnet-api.binance.org/bc/", "wss://testnet-dex.binance.org/api", @@ -23,7 +23,7 @@ public class BNBDexEnvironment { "bva" ); - public static final BNBDexEnvironment LOCAL_NET = new BNBDexEnvironment( + public static final BinanceDexEnvironment LOCAL_NET = new BinanceDexEnvironment( "https://testnet-dex.binance.org", "https://testnet-api.binance.org/bc/", "wss://testnet-dex.binance.org/api", diff --git a/src/main/java/com/binance/dex/api/client/BinanceDexNodeApi.java b/src/main/java/com/binance/dex/api/client/BinanceDexNodeApi.java index 6b0ca77..edab597 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceDexNodeApi.java +++ b/src/main/java/com/binance/dex/api/client/BinanceDexNodeApi.java @@ -6,7 +6,7 @@ import retrofit2.http.GET; import retrofit2.http.Query; -public interface BNBDexNodeApi { +public interface BinanceDexNodeApi { @GET("/abci_query") Call> getAccount(@Query("path") String pathWithAddress); diff --git a/src/main/java/com/binance/dex/api/client/BinanceTransactionApi.java b/src/main/java/com/binance/dex/api/client/BinanceTransactionApi.java index 0199a8d..314d894 100644 --- a/src/main/java/com/binance/dex/api/client/BinanceTransactionApi.java +++ b/src/main/java/com/binance/dex/api/client/BinanceTransactionApi.java @@ -6,7 +6,7 @@ import retrofit2.http.Path; import retrofit2.http.Query; -public interface BNBTransactionApi { +public interface BinanceTransactionApi { @GET("api/v1/txs") Call getTransactions(@Query(value = "startTime") Long startTime, @Query(value = "endTime") Long endTime, From 5a699459b7d565b2ac3f44136ac0e4f8e2bd1f98 Mon Sep 17 00:00:00 2001 From: forcodedancing Date: Wed, 2 Aug 2023 15:36:24 +0800 Subject: [PATCH 50/52] fix: fix side vote addr not parsed issue --- LICENSE | 2 +- .../dex/api/client/TransactionConverter.java | 6 +++++- .../EditSideChainValidatorWithVoteAddr.java | 13 +++++++++++- ...SideChainValidatorWithVoteAddrMessage.java | 21 ++++++++++++++++++- .../dex/api/client/encoding/AminoTest.java | 10 +++++---- .../client/examples/NodeClientExample.java | 6 +++--- 6 files changed, 47 insertions(+), 11 deletions(-) diff --git a/LICENSE b/LICENSE index f48a48c..2b3b563 100644 --- a/LICENSE +++ b/LICENSE @@ -186,7 +186,7 @@ same "printed page" as the copyright notice for easier identification within third-party archives. - Copyright 2018-2019 Binance + Copyright 2018-2019 All BNB Chain Developers Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/src/main/java/com/binance/dex/api/client/TransactionConverter.java b/src/main/java/com/binance/dex/api/client/TransactionConverter.java index f54e2d0..ee89642 100644 --- a/src/main/java/com/binance/dex/api/client/TransactionConverter.java +++ b/src/main/java/com/binance/dex/api/client/TransactionConverter.java @@ -1423,8 +1423,12 @@ private Transaction convertEditSideChainValidatorWithVoteAddr(byte[] value) thro editSideChainValidator.setSideFeeAddr("0x" + Hex.toHexString(message.getSideFeeAddr())); } + if (message.getSideConsAddr() != null) { + editSideChainValidator.setSideConsAddr("0x" + Hex.toHexString(message.getSideConsAddr())); + } + if (message.getSideVoteAddr() != null) { - editSideChainValidator.setSideVoteAddr("0x" + Hex.toHexString(message.getSideVoteAddr())); + editSideChainValidator.setSideVoteAddr("0x"+ Hex.toHexString(message.getSideVoteAddr())); } Transaction transaction = new Transaction(); diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/EditSideChainValidatorWithVoteAddr.java b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/EditSideChainValidatorWithVoteAddr.java index 44ea59f..252a422 100644 --- a/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/EditSideChainValidatorWithVoteAddr.java +++ b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/EditSideChainValidatorWithVoteAddr.java @@ -14,6 +14,8 @@ public class EditSideChainValidatorWithVoteAddr { private String sideFeeAddr; + private String sideConsAddr; + private String sideVoteAddr; public EditSideChainValidatorWithVoteAddr() { @@ -59,6 +61,14 @@ public void setSideFeeAddr(String sideFeeAddr) { this.sideFeeAddr = sideFeeAddr; } + public String getSideConsAddr() { + return sideConsAddr; + } + + public void setSideConsAddr(String sideConsAddr) { + this.sideConsAddr = sideConsAddr; + } + public String getSideVoteAddr() { return sideVoteAddr; } @@ -69,12 +79,13 @@ public void setSideVoteAddr(String sideVoteAddr) { @Override public String toString() { - return "EditSideChainValidator{" + + return "EditSideChainValidatorWithVoteAddr{" + "description=" + description + "\n" + ", validatorAddress='" + validatorAddress + '\'' + "\n" + ", commissionRate=" + commissionRate + "\n" + ", sideChainId='" + sideChainId + '\'' + "\n" + ", sideFeeAddr='" + sideFeeAddr + '\'' + "\n" + + ", sideConsAddr='" + sideConsAddr + '\'' + "\n" + ", sideVoteAddr='" + sideVoteAddr + '\'' + "\n" + '}'; } diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/EditSideChainValidatorWithVoteAddrMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/EditSideChainValidatorWithVoteAddrMessage.java index c139f58..9a8e944 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/EditSideChainValidatorWithVoteAddrMessage.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/EditSideChainValidatorWithVoteAddrMessage.java @@ -14,6 +14,7 @@ import org.apache.commons.lang3.StringUtils; import java.util.ArrayList; +import java.util.Arrays; /** * @author Fitz.Lu @@ -38,6 +39,9 @@ public class EditSideChainValidatorWithVoteAddrMessage implements BinanceDexTran @JsonProperty(value = "side_fee_addr") private byte[] sideFeeAddr; + @JsonProperty(value = "side_cons_addr") + private byte[] sideConsAddr; + @JsonProperty(value = "side_vote_addr") private byte[] sideVoteAddr; @@ -60,7 +64,10 @@ public void setValueByFieldIndex(int fieldIndex, Object value) { sideFeeAddr = ((byte[]) value); break; case 6: - sideVoteAddr = ((byte[]) value); + sideConsAddr = ((byte[]) value); + break; + case 7: + setSideVoteAddr((byte[]) value); break; default: break; @@ -110,11 +117,22 @@ public void setSideFeeAddr(byte[] sideFeeAddr) { this.sideFeeAddr = sideFeeAddr; } + public byte[] getSideConsAddr() { + return sideConsAddr; + } + + public void setSideConsAddr(byte[] sideConsAddr) { + this.sideConsAddr = sideConsAddr; + } + public byte[] getSideVoteAddr() { return sideVoteAddr; } public void setSideVoteAddr(byte[] sideVoteAddr) { + if (sideVoteAddr != null && sideVoteAddr.length > 48) { + sideVoteAddr = Arrays.copyOfRange(sideVoteAddr, 0, 48); + } this.sideVoteAddr = sideVoteAddr; } @@ -136,6 +154,7 @@ public ArrayList> IterateFields() { .addField(Dec.class, commissionRate, commissionRate == null || commissionRate.isDefaultOrEmpty()) .addField(String.class, sideChainId, StringUtils.isEmpty(sideChainId)) .addField(byte[].class, sideFeeAddr, sideFeeAddr == null || sideFeeAddr.length == 0) + .addField(byte[].class, sideConsAddr, sideConsAddr == null || sideConsAddr.length == 0) .addField(byte[].class, sideVoteAddr, sideVoteAddr == null || sideVoteAddr.length == 0) .build(); } diff --git a/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java b/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java index baad17a..c343286 100644 --- a/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java +++ b/src/test/java/com/binance/dex/api/client/encoding/AminoTest.java @@ -305,17 +305,18 @@ public void testDecodeEditSideChainValidatorWithVoteAddr() throws IOException { //set new rate if needed editSideChainValidator.setCommissionRate(1L); - //set new fee address if needed - editSideChainValidator.setSideFeeAddr("0xd1B22dCC24C55f4d728E7aaA5c9b5a22e1512C08"); - editSideChainValidator.setSideChainId("bsc"); - editSideChainValidator.setSideVoteAddr("0x11FfBAC7fA17f5c9084a15C8f0f15dAe845A5712"); + //set new fee address if needed + editSideChainValidator.setSideFeeAddr("0xd1B22dCC24C55f4d728E7aaA5c9b5a22e1512C08"); + editSideChainValidator.setSideConsAddr("0xd1B22dCC24C55f4d728E7aaA5c9b5a22e1512C99"); + editSideChainValidator.setSideVoteAddr("0xa96c45e0043e98a4271d84265a0a5177795c61aa188c42a94ecc4b2e54073613a46f49ff1c03e29d4a744fd56589e3a0"); byte[] msg = amino.encode(convert(editSideChainValidator), MessageType.EditSideChainValidatorWithVoteAddr.getTypePrefixBytes(), false); Transaction tx = transactionConverter.convert(msg); Assert.assertNotNull(tx.getRealTx()); + Assert.assertEquals("0xa96c45e0043e98a4271d84265a0a5177795c61aa188c42a94ecc4b2e54073613a46f49ff1c03e29d4a744fd56589e3a0", ((EditSideChainValidatorWithVoteAddr)tx.getRealTx()).getSideVoteAddr()); } EditSideChainValidatorMessage convert(EditSideChainValidator editSideChainValidator) { @@ -453,6 +454,7 @@ EditSideChainValidatorWithVoteAddrMessage convert(EditSideChainValidatorWithVote message.setCommissionRate(Dec.newInstance(editSideChainValidator.getCommissionRate())); message.setSideChainId(editSideChainValidator.getSideChainId()); message.setSideFeeAddr(decodeHexAddress(editSideChainValidator.getSideFeeAddr())); + message.setSideConsAddr(decodeHexAddress(editSideChainValidator.getSideConsAddr())); message.setSideVoteAddr(decodeHexAddress(editSideChainValidator.getSideVoteAddr())); return message; diff --git a/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java b/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java index a5a33f2..ad1440f 100644 --- a/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java +++ b/src/test/java/com/binance/dex/api/client/examples/NodeClientExample.java @@ -27,7 +27,7 @@ public class NodeClientExample { @Before public void setup() { - binanceDexNodeApi = BinanceDexApiClientFactory.newInstance().newNodeRpcClient(BinanceDexEnvironment.LOCAL_NET.getNodeUrl(), BinanceDexEnvironment.LOCAL_NET.getHrp(), BinanceDexEnvironment.LOCAL_NET.getValHrp()); + binanceDexNodeApi = BinanceDexApiClientFactory.newInstance().newNodeRpcClient(BinanceDexEnvironment.PROD.getNodeUrl(), BinanceDexEnvironment.PROD.getHrp(), BinanceDexEnvironment.PROD.getValHrp()); } @Test @@ -293,14 +293,14 @@ public void testGetSideProposalById() { @Test public void testCreateSidechainValidatorWithVoteAddr() { - Transaction transaction = binanceDexNodeApi.getTransaction("0B660182B6E571A2BF9644624EA75890FC5C87F45759B4B0CC74BAA63B61501C"); + Transaction transaction = binanceDexNodeApi.getTransaction("7A6A818048DBE4330BC72DD169F684F2E51E8780185A140E1F1B0AF5414EA48A"); Assert.assertNotNull(transaction); Assert.assertEquals(transaction.getTxType(), TxType.CREATE_SIDECHAIN_VALIDATOR_WITH_VOTE_ADDR); } @Test public void testEditSidechainValidatorWithVoteAddr() { - Transaction transaction = binanceDexNodeApi.getTransaction("037A67C45ADFEE6F978D1B02EEB18BAD6EE427C3BA55674B3F2C421E42E7D1DB"); + Transaction transaction = binanceDexNodeApi.getTransaction("30A5699E193929FB04F1D6C151303ABAA4E9D51CC1F718A9E8BD4E086DFDE305"); Assert.assertNotNull(transaction); Assert.assertEquals(transaction.getTxType(), TxType.EDIT_SIDECHAIN_VALIDATOR_WITH_VOTE_ADDR); } From cb2e80a06eb3267b3dbec424c62003c9dfdad38e Mon Sep 17 00:00:00 2001 From: forcodedancing Date: Mon, 4 Mar 2024 10:23:03 +0800 Subject: [PATCH 51/52] feat: add support for SideChainStakeMigration (#150) --- .../dex/api/client/TransactionConverter.java | 42 +++++- .../api/client/domain/broadcast/TxType.java | 1 + .../sidechain/SideChainStakeMigration.java | 70 ++++++++++ .../client/encoding/message/MessageType.java | 4 +- .../SideChainStakeMigrationMessage.java | 120 ++++++++++++++++++ .../api/client/utils/converter/TxType.java | 3 +- .../FSideChainStakeMigrationConverter.java | 33 +++++ 7 files changed, 270 insertions(+), 3 deletions(-) create mode 100644 src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainStakeMigration.java create mode 100644 src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainStakeMigrationMessage.java create mode 100644 src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideChainStakeMigrationConverter.java diff --git a/src/main/java/com/binance/dex/api/client/TransactionConverter.java b/src/main/java/com/binance/dex/api/client/TransactionConverter.java index ee89642..9fe8f99 100644 --- a/src/main/java/com/binance/dex/api/client/TransactionConverter.java +++ b/src/main/java/com/binance/dex/api/client/TransactionConverter.java @@ -252,6 +252,8 @@ public Transaction convert(byte[] bytes) { return convertCreateSideChainValidatorWithVoteAddr(bytes); case EditSideChainValidatorWithVoteAddr: return convertEditSideChainValidatorWithVoteAddr(bytes); + case SideChainStakeMigration: + return convertSideChainStakeMigration(bytes); } return null; } catch (Exception e) { @@ -1428,7 +1430,7 @@ private Transaction convertEditSideChainValidatorWithVoteAddr(byte[] value) thro } if (message.getSideVoteAddr() != null) { - editSideChainValidator.setSideVoteAddr("0x"+ Hex.toHexString(message.getSideVoteAddr())); + editSideChainValidator.setSideVoteAddr("0x" + Hex.toHexString(message.getSideVoteAddr())); } Transaction transaction = new Transaction(); @@ -1437,4 +1439,42 @@ private Transaction convertEditSideChainValidatorWithVoteAddr(byte[] value) thro return transaction; } + + private Transaction convertSideChainStakeMigration(byte[] value) throws IOException { + byte[] raw = ByteUtil.cut(value, 4); + SideChainStakeMigrationMessage message = new SideChainStakeMigrationMessage(); + amino.decodeBare(raw, message); + + SideChainStakeMigration stakeMigration = new SideChainStakeMigration(); + + if (message.getValidatorSrcAddr() != null && message.getValidatorSrcAddr().getRaw() != null) { + stakeMigration.setValidatorSrcAddr(Crypto.encodeAddress(valHrp, message.getValidatorSrcAddr().getRaw())); + } + + if (message.getValidatorDstAddr() != null) { + stakeMigration.setValidatorDstAddr("0x" + Hex.toHexString(message.getValidatorDstAddr())); + } + + if (message.getDelegatorAddr() != null) { + stakeMigration.setDelegatorAddr("0x" + Hex.toHexString(message.getDelegatorAddr())); + } + + if (message.getRefundAddr() != null && message.getRefundAddr().getRaw() != null) { + stakeMigration.setRefundAddr(Crypto.encodeAddress(hrp, message.getRefundAddr().getRaw())); + } + + Token amount = new Token(); + if (message.getAmount() != null) { + amount.setAmount(message.getAmount().getAmount()); + amount.setDenom(message.getAmount().getDenom()); + } + stakeMigration.setAmount(amount); + + + Transaction transaction = new Transaction(); + transaction.setTxType(TxType.SIDECHAIN_STAKE_MIGRATION); + transaction.setRealTx(stakeMigration); + + return transaction; + } } diff --git a/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java b/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java index 925b15b..7fcbac9 100644 --- a/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java +++ b/src/main/java/com/binance/dex/api/client/domain/broadcast/TxType.java @@ -50,4 +50,5 @@ public enum TxType { UNJAIL, CREATE_SIDECHAIN_VALIDATOR_WITH_VOTE_ADDR, EDIT_SIDECHAIN_VALIDATOR_WITH_VOTE_ADDR, + SIDECHAIN_STAKE_MIGRATION, } diff --git a/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainStakeMigration.java b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainStakeMigration.java new file mode 100644 index 0000000..76eeb93 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/domain/stake/sidechain/SideChainStakeMigration.java @@ -0,0 +1,70 @@ +package com.binance.dex.api.client.domain.stake.sidechain; + +import com.binance.dex.api.client.encoding.message.Token; + +public class SideChainStakeMigration { + + private String validatorSrcAddr; + + private String validatorDstAddr; + + private String delegatorAddr; + + private String refundAddr; + + private Token amount; + + public SideChainStakeMigration() { + } + + public String getValidatorSrcAddr() { + return validatorSrcAddr; + } + + public void setValidatorSrcAddr(String validatorSrcAddr) { + this.validatorSrcAddr = validatorSrcAddr; + } + + public String getValidatorDstAddr() { + return validatorDstAddr; + } + + public void setValidatorDstAddr(String validatorDstAddr) { + this.validatorDstAddr = validatorDstAddr; + } + + public String getDelegatorAddr() { + return delegatorAddr; + } + + public void setDelegatorAddr(String delegatorAddr) { + this.delegatorAddr = delegatorAddr; + } + + public String getRefundAddr() { + return refundAddr; + } + + public void setRefundAddr(String refundAddr) { + this.refundAddr = refundAddr; + } + + public Token getAmount() { + return amount; + } + + public void setAmount(Token amount) { + this.amount = amount; + } + + @Override + public String toString() { + return "SideChainStakeMigration{" + + "validatorSrcAddr='" + validatorSrcAddr + '\'' + + ", validatorDstAddr='" + validatorDstAddr + '\'' + + ", delegatorAddr='" + delegatorAddr + '\'' + + ", refundAddr='" + refundAddr + '\'' + + ", amount=" + amount + + '}'; + } +} diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java b/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java index 813900c..bf0c3c5 100644 --- a/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java +++ b/src/main/java/com/binance/dex/api/client/encoding/message/MessageType.java @@ -65,7 +65,9 @@ public enum MessageType { // fast finality CreateSideChainValidatorWithVoteAddr("A0032998"), - EditSideChainValidatorWithVoteAddr("852FDADD"); + EditSideChainValidatorWithVoteAddr("852FDADD"), + + SideChainStakeMigration("38589196"); private byte[] typePrefixBytes; diff --git a/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainStakeMigrationMessage.java b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainStakeMigrationMessage.java new file mode 100644 index 0000000..be255ab --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/encoding/message/sidechain/transaction/SideChainStakeMigrationMessage.java @@ -0,0 +1,120 @@ +package com.binance.dex.api.client.encoding.message.sidechain.transaction; + +import com.binance.dex.api.client.encoding.amino.AminoField; +import com.binance.dex.api.client.encoding.amino.AminoSerializable; +import com.binance.dex.api.client.encoding.message.BinanceDexTransactionMessage; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.encoding.message.common.CoinValueStr; +import com.fasterxml.jackson.annotation.JsonIgnoreProperties; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import org.apache.commons.lang3.StringUtils; + +import java.util.ArrayList; + +@JsonIgnoreProperties(ignoreUnknown = true) +@JsonPropertyOrder(alphabetic = true) +public class SideChainStakeMigrationMessage implements BinanceDexTransactionMessage, AminoSerializable { + + @JsonProperty(value = "validator_src_addr") + private Bech32AddressValue validatorSrcAddr; + + @JsonProperty(value = "validator_dst_addr") + private byte[] validatorDstAddr; + + @JsonProperty(value = "delegator_addr") + private byte[] delegatorAddr; + + @JsonProperty(value = "refund_addr") + private Bech32AddressValue refundAddr; + + @JsonProperty(value = "amount") + private CoinValueStr amount; + + public SideChainStakeMigrationMessage() { + } + + @Override + public AminoSerializable newAminoMessage() { + return new SideChainStakeMigrationMessage(); + } + + @Override + public ArrayList> IterateFields() { + return AminoField.newFieldsBuilder() + .addField(Bech32AddressValue.class, validatorSrcAddr, validatorSrcAddr == null || validatorSrcAddr.isDefaultOrEmpty()) + .addField(byte[].class, validatorDstAddr, validatorDstAddr == null || validatorDstAddr.length == 0) + .addField(byte[].class, delegatorAddr, delegatorAddr == null || delegatorAddr.length == 0) + .addField(Bech32AddressValue.class, refundAddr, refundAddr == null || refundAddr.isDefaultOrEmpty()) + .addField(CoinValueStr.class, amount, amount == null) + .build(); + } + + @Override + public void setValueByFieldIndex(int fieldIndex, Object value) { + switch (fieldIndex) { + case 1: + validatorSrcAddr = ((Bech32AddressValue) value); + break; + case 2: + validatorDstAddr = ((byte[]) value); + break; + case 3: + delegatorAddr = ((byte[]) value); + break; + case 4: + refundAddr = ((Bech32AddressValue) value); + break; + case 5: + amount = ((CoinValueStr) value); + break; + default: + break; + } + } + + @Override + public boolean useAminoJson() { + return true; + } + + public Bech32AddressValue getValidatorSrcAddr() { + return validatorSrcAddr; + } + + public void setValidatorSrcAddr(Bech32AddressValue validatorSrcAddr) { + this.validatorSrcAddr = validatorSrcAddr; + } + + public byte[] getValidatorDstAddr() { + return validatorDstAddr; + } + + public void setValidatorDstAddr(byte[] validatorDstAddr) { + this.validatorDstAddr = validatorDstAddr; + } + + public byte[] getDelegatorAddr() { + return delegatorAddr; + } + + public void setDelegatorAddr(byte[] delegatorAddr) { + this.delegatorAddr = delegatorAddr; + } + + public Bech32AddressValue getRefundAddr() { + return refundAddr; + } + + public void setRefundAddr(Bech32AddressValue refundAddr) { + this.refundAddr = refundAddr; + } + + public CoinValueStr getAmount() { + return amount; + } + + public void setAmount(CoinValueStr amount) { + this.amount = amount; + } +} diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/TxType.java b/src/main/java/com/binance/dex/api/client/utils/converter/TxType.java index 38d67f7..ab88a90 100644 --- a/src/main/java/com/binance/dex/api/client/utils/converter/TxType.java +++ b/src/main/java/com/binance/dex/api/client/utils/converter/TxType.java @@ -52,7 +52,8 @@ public enum TxType { BEACONCHAIN_UNDELEGATE(com.binance.dex.api.client.domain.broadcast.TxType.BEACONCHAIN_UNDELEGATE), UNJAIL(com.binance.dex.api.client.domain.broadcast.TxType.UNJAIL), CREATE_SIDECHAIN_VALIDATOR_WITH_VOTE_ADDR(com.binance.dex.api.client.domain.broadcast.TxType.CREATE_SIDECHAIN_VALIDATOR_WITH_VOTE_ADDR), - EDIT_SIDECHAIN_VALIDATOR_WITH_VOTE_ADDR(com.binance.dex.api.client.domain.broadcast.TxType.EDIT_SIDECHAIN_VALIDATOR_WITH_VOTE_ADDR); + EDIT_SIDECHAIN_VALIDATOR_WITH_VOTE_ADDR(com.binance.dex.api.client.domain.broadcast.TxType.EDIT_SIDECHAIN_VALIDATOR_WITH_VOTE_ADDR), + SIDECHAIN_STAKE_MIGRATION(com.binance.dex.api.client.domain.broadcast.TxType.SIDECHAIN_STAKE_MIGRATION); private com.binance.dex.api.client.domain.broadcast.TxType code; diff --git a/src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideChainStakeMigrationConverter.java b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideChainStakeMigrationConverter.java new file mode 100644 index 0000000..733bfb0 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/utils/converter/impl/FSideChainStakeMigrationConverter.java @@ -0,0 +1,33 @@ +package com.binance.dex.api.client.utils.converter.impl; + +import com.binance.dex.api.client.domain.Transaction; +import com.binance.dex.api.client.domain.TransactionV2; +import com.binance.dex.api.client.domain.broadcast.TxType; +import com.binance.dex.api.client.domain.stake.sidechain.SideChainRedelegate; +import com.binance.dex.api.client.domain.stake.sidechain.SideChainStakeMigration; +import com.binance.dex.api.client.utils.converter.JsonUtil; +import com.binance.dex.api.client.utils.converter.NumberUtil; +import com.binance.dex.api.client.utils.converter.Token; +import com.binance.dex.api.client.utils.converter.TransactionConverter; + +import java.util.Map; + +public class FSideChainStakeMigrationConverter extends TransactionConverter { + + @Override + public TxType getType() { + return TxType.SIDECHAIN_STAKE_MIGRATION; + } + + @Override + public void doConvert(TransactionV2 transactionV2, Transaction transaction) { + transaction.setValue(NumberUtil.longToBigDecimalString(transactionV2.getAmount())); + + Map map = JsonUtil.fromJson(transactionV2.getData(), Map.class); + if (transaction.getValue() == null || transaction.getTxAsset() == null) { + Token token = getToken(map, "amount"); + transaction.setTxAsset(token.getDenom()); + transaction.setValue(NumberUtil.longToBigDecimalString(token.getAmount())); + } + } +} From 0ac864212c1223ee6bb69c933a122adb45aba1aa Mon Sep 17 00:00:00 2001 From: forcodedancing Date: Thu, 11 Apr 2024 10:25:03 +0800 Subject: [PATCH 52/52] fix: stake migration refund package is not correctly handled (#151) --- pom.xml | 2 +- .../api/client/crosschain/ContentEnum.java | 3 +++ .../content/StakeMigrationRefund.java | 23 +++++++++++++++++++ 3 files changed, 27 insertions(+), 1 deletion(-) create mode 100644 src/main/java/com/binance/dex/api/client/crosschain/content/StakeMigrationRefund.java diff --git a/pom.xml b/pom.xml index 5e81d35..11d56d7 100644 --- a/pom.xml +++ b/pom.xml @@ -5,7 +5,7 @@ com.binance.dex.api binance-dex-api-client - 1.1.6 + 1.1.8 diff --git a/src/main/java/com/binance/dex/api/client/crosschain/ContentEnum.java b/src/main/java/com/binance/dex/api/client/crosschain/ContentEnum.java index c2ce6f6..5aa1951 100644 --- a/src/main/java/com/binance/dex/api/client/crosschain/ContentEnum.java +++ b/src/main/java/com/binance/dex/api/client/crosschain/ContentEnum.java @@ -26,6 +26,9 @@ public enum ContentEnum { CrossStakeSynPack(16, 0, CrossStakeSyn.class), CrossStakeRefundPack(16, 1, CrossStakeRefund.class), CrossStakeFailAckPack(16, 2, CrossStakeFailAck.class), + StakeMigrationSynPack(17, 0, StakeMigrationRefund.class), + StakeMigrationAckPack(17, 1, StakeMigrationRefund.class), + StakeMigrationFailAckPack(17, 2, StakeMigrationRefund.class), ; private Integer channelId; diff --git a/src/main/java/com/binance/dex/api/client/crosschain/content/StakeMigrationRefund.java b/src/main/java/com/binance/dex/api/client/crosschain/content/StakeMigrationRefund.java new file mode 100644 index 0000000..6bb2a91 --- /dev/null +++ b/src/main/java/com/binance/dex/api/client/crosschain/content/StakeMigrationRefund.java @@ -0,0 +1,23 @@ +package com.binance.dex.api.client.crosschain.content; + +import com.binance.dex.api.client.crosschain.*; +import com.binance.dex.api.client.encoding.message.common.Bech32AddressValue; +import com.binance.dex.api.client.encoding.message.common.EthAddressValue; +import lombok.Getter; +import lombok.Setter; + + +@Getter +@Setter +public class StakeMigrationRefund extends Content { + + private EthAddressValue operatorAddress; + private EthAddressValue delegatorAddress; + private Bech32AddressValue refundAddress; + private UnsignedNumber amount; + + @Override + protected void setHrp(String hrp) { + this.refundAddress.setHrp(hrp); + } +}