mirrors/bisq
1
0
Fork 0
mirror of https://github.com/bisq-network/bisq.git synced 2025-02-24 07:07:43 +01:00
Code Issues Projects Releases Packages Wiki Activity

Refactoring: apply Lombok, cleanup

Browse source
This commit is contained in:
Manfred Karrer 2017-05-13 16:04:03 +02:00
parent 603c3c512e
commit 824e26eeca
44 changed files with 712 additions and 869 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
common/src/main/java/io/bisq/common/crypto/CryptoUtils.java
View file

@ -18,13 +18,8 @@
package io.bisq.common.crypto;
import lombok.extern.slf4j.Slf4j;
import org.jetbrains.annotations.NotNull;
import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.PublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
@ -34,10 +29,5 @@ public class CryptoUtils {
final X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(publicKey.getEncoded());
return Base64.getEncoder().encodeToString(x509EncodedKeySpec.getEncoded());
}
public static PublicKey getPubKeyFromBytes(@NotNull byte[] publicKeyBytes)
throws NoSuchProviderException, NoSuchAlgorithmException, InvalidKeySpecException {
return KeyFactory.getInstance(Sig.KEY_ALGO, "BC").generatePublic(new X509EncodedKeySpec(publicKeyBytes));
}
}

13
common/src/main/java/io/bisq/common/crypto/PubKeyRing.java
View file

@ -39,14 +39,13 @@ import java.security.PublicKey;
public final class PubKeyRing implements NetworkPayload {
private final byte[] signaturePubKeyBytes;
private final byte[] encryptionPubKeyBytes;
private String pgpPubKeyAsPem;
transient private PublicKey signaturePubKey;
transient private PublicKey encryptionPubKey;
@Nullable
// TODO remove Nullable once impl.
transient private PGPPublicKey pgpPubKey;
private final String pgpPubKeyAsPem;
private PublicKey signaturePubKey;
private PublicKey encryptionPubKey;
@Nullable
private PGPPublicKey pgpPubKey;
public PubKeyRing(PublicKey signaturePubKey, PublicKey encryptionPubKey, @Nullable PGPPublicKey pgpPubKey) {
this.signaturePubKeyBytes = Sig.getSigPublicKeyBytes(signaturePubKey);

36
common/src/main/java/io/bisq/common/locale/TradeCurrency.java
View file

@ -17,6 +17,7 @@
package io.bisq.common.locale;
import io.bisq.common.proto.ProtobufferException;
import io.bisq.common.proto.persistable.PersistablePayload;
import io.bisq.generated.protobuffer.PB;
import lombok.EqualsAndHashCode;
@ -47,6 +48,29 @@ public abstract class TradeCurrency implements PersistablePayload, Comparable<Tr
this.symbol = symbol;
}
///////////////////////////////////////////////////////////////////////////////////////////
// PROTO BUFFER
///////////////////////////////////////////////////////////////////////////////////////////
public static TradeCurrency fromProto(PB.TradeCurrency proto) {
switch (proto.getMessageCase()) {
case FIAT_CURRENCY:
return new FiatCurrency(proto.getCode());
case CRYPTO_CURRENCY:
return new CryptoCurrency(proto.getCode(),
proto.getName(),
proto.getSymbol(),
proto.getCryptoCurrency().getIsAsset());
default:
throw new ProtobufferException("Unknown message case: " + proto.getMessageCase());
}
}
///////////////////////////////////////////////////////////////////////////////////////////
// API
///////////////////////////////////////////////////////////////////////////////////////////
public String getDisplayPrefix() {
return "";
}
@ -64,16 +88,4 @@ public abstract class TradeCurrency implements PersistablePayload, Comparable<Tr
return this.code.compareTo(other.code);
}
public static TradeCurrency fromProto(PB.TradeCurrency tradeCurrency) {
switch (tradeCurrency.getMessageCase()) {
case FIAT_CURRENCY:
return new FiatCurrency(tradeCurrency.getCode());
case CRYPTO_CURRENCY:
return new CryptoCurrency(tradeCurrency.getCode(), tradeCurrency.getName(), tradeCurrency.getSymbol(),
tradeCurrency.getCryptoCurrency().getIsAsset());
default:
log.warn("Unknown tradecurrency: {}", tradeCurrency.getMessageCase());
return null;
}
}
}

4
common/src/main/java/io/bisq/common/proto/ProtoCollectionUtil.java
View file

@ -30,8 +30,8 @@ public class ProtoCollectionUtil {
// Convenience
///////////////////////////////////////////////////////////////////////////////////////////
public static Iterable collectionToProto(Collection<? extends Payload> collection) {
return collection.stream().map(e -> e.toProtoMessage()).collect(Collectors.toList());
public static <T extends Message> Iterable<T> collectionToProto(Collection<? extends Payload> collection) {
return collection.stream().map(e -> (T) e.toProtoMessage()).collect(Collectors.toList());
}
public static <T> Iterable<T> collectionToProto(Collection<? extends Payload> collection, Function<? super Message, T> extra) {

5
common/src/main/java/io/bisq/common/proto/persistable/PersistableList.java
View file

@ -20,11 +20,9 @@ package io.bisq.common.proto.persistable;
import com.google.protobuf.Message;
import lombok.Getter;
import lombok.Setter;
import sun.reflect.generics.reflectiveObjects.NotImplementedException;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.function.Function;
import java.util.stream.Collectors;
@ -61,9 +59,6 @@ public class PersistableList<T extends PersistablePayload> implements Persistabl
@Override
public Message toProtoMessage() {
if (Objects.isNull(toProto)) {
throw new NotImplementedException();
}
return toProto.apply(list);
}

31
common/src/main/proto/pb.proto
View file

@ -396,21 +396,22 @@ message Alert {
string version = 2;
bool is_update_info = 3;
string signature_as_base64 = 4;
bytes storage_public_key_bytes = 5;
map<string, string> extra_data_map = 6;
bytes owner_pub_key_bytes = 5;
map<string, string> extra_data = 6;
}
message Arbitrator {
NodeAddress node_address = 1;
repeated string language_codes = 2;
int64 registration_date = 3;
bytes registration_signature = 4;
string registration_signature = 4;
bytes registration_pub_key = 5;
PubKeyRing pub_key_ring = 6;
bytes btc_pub_key = 7;
string btc_address = 8;
string email_address = 9;
map<string, string> extra_data_map = 10;
string info = 10;
map<string, string> extra_data = 11;
}
message Mediator {
@ -422,7 +423,7 @@ message Mediator {
PubKeyRing pub_key_ring = 6;
string email_address = 7;
string info = 8;
map<string, string> extra_data_map = 9;
map<string, string> extra_data = 9;
}
message Filter {
@ -431,7 +432,7 @@ message Filter {
repeated PaymentAccountFilter banned_payment_accounts = 3;
string signature_as_base64 = 4;
bytes owner_pub_key_bytes = 5;
map<string, string> extra_data_map = 6;
map<string, string> extra_data = 6;
}
message PaymentAccountFilter {
@ -454,11 +455,11 @@ message CompensationRequestPayload {
int64 requested_btc = 11;
string btc_address = 12;
string node_address = 13;
bytes p2p_storage_signature_pub_key_bytes = 14;
string p2p_storage_signature_pub_key_as_hex = 15;
bytes owner_pub_key_bytes = 14;
string owner_pub_key_as_hex = 15;
string signature = 16;
string fee_tx_id = 17;
map<string, string> extra_data_map = 18;
map<string, string> extra_data = 18;
}
message TradeStatistics {
@ -470,14 +471,14 @@ message TradeStatistics {
int64 trade_date = 6;
string payment_method_id = 7;
int64 offer_date = 8;
bool use_market_based_price = 9;
double market_price_margin = 10;
bool offer_use_market_based_price = 9;
double offer_market_price_margin = 10;
int64 offer_amount = 11;
int64 offer_min_amount = 12;
string offer_id = 13;
string deposit_tx_id = 14;
PubKeyRing pub_key_ring = 15;
map<string, string> extra_data_map = 16;
map<string, string> extra_data = 16;
}
@ -485,7 +486,7 @@ message MailboxStoragePayload {
PrefixedSealedAndSignedMessage prefixed_sealed_and_signed_message = 1;
bytes sender_pub_key_for_add_operation_bytes = 2;
bytes owner_pub_key_bytes = 3;
map<string, string> extra_data_map = 4;
map<string, string> extra_data = 4;
}
message OfferPayload {
@ -512,7 +513,7 @@ message OfferPayload {
double market_price_margin = 16;
int64 amount = 17;
int64 min_amount = 18;
NodeAddress maker_node_address = 19;
NodeAddress owner_node_address = 19;
PubKeyRing pub_key_ring = 20;
string maker_payment_account_id = 21;
string offer_fee_payment_tx_id = 22;
@ -530,7 +531,7 @@ message OfferPayload {
int64 upper_close_price = 34;
bool is_private_offer = 35;
string hash_of_challenge = 36;
map<string, string> extra_data_map = 37;
map<string, string> extra_data = 37;
bool is_currency_for_maker_fee_btc = 38;
}

31
core/src/main/java/io/bisq/core/alert/Alert.java
View file

@ -41,6 +41,7 @@ import static com.google.common.base.Preconditions.checkNotNull;
@ToString
@Slf4j
public final class Alert implements StoragePayload {
private final long TTL = TimeUnit.DAYS.toMillis(30);
private final String message;
private final String version;
private final boolean isUpdateInfo;
@ -92,23 +93,23 @@ public final class Alert implements StoragePayload {
checkNotNull(ownerPubKeyBytes, "storagePublicKeyBytes must not be null");
checkNotNull(signatureAsBase64, "signatureAsBase64 must not be null");
final PB.Alert.Builder builder = PB.Alert.newBuilder()
.setMessage(getMessage())
.setIsUpdateInfo(isUpdateInfo())
.setVersion(getVersion())
.setMessage(message)
.setIsUpdateInfo(isUpdateInfo)
.setVersion(version)
.setOwnerPubKeyBytes(ByteString.copyFrom(ownerPubKeyBytes))
.setSignatureAsBase64(getSignatureAsBase64());
.setSignatureAsBase64(signatureAsBase64);
Optional.ofNullable(getExtraDataMap()).ifPresent(builder::putAllExtraData);
return PB.StoragePayload.newBuilder().setAlert(builder).build();
}
public static Alert fromProto(PB.Alert alert) {
return new Alert(alert.getMessage(),
alert.getIsUpdateInfo(),
alert.getVersion(),
alert.getOwnerPubKeyBytes().toByteArray(),
alert.getSignatureAsBase64(),
CollectionUtils.isEmpty(alert.getExtraDataMap()) ?
null : alert.getExtraDataMap());
public static Alert fromProto(PB.Alert proto) {
return new Alert(proto.getMessage(),
proto.getIsUpdateInfo(),
proto.getVersion(),
proto.getOwnerPubKeyBytes().toByteArray(),
proto.getSignatureAsBase64(),
CollectionUtils.isEmpty(proto.getExtraDataMap()) ?
null : proto.getExtraDataMap());
}
@ -119,15 +120,11 @@ public final class Alert implements StoragePayload {
public void setSigAndPubKey(String signatureAsBase64, PublicKey ownerPubKey) {
this.signatureAsBase64 = signatureAsBase64;
this.ownerPubKey = ownerPubKey;
ownerPubKeyBytes = Sig.getSigPublicKeyBytes(ownerPubKey);
}
public boolean isNewVersion() {
return Version.isNewVersion(version);
}
@Override
public long getTTL() {
return TimeUnit.DAYS.toMillis(30);
}
}

85
core/src/main/java/io/bisq/core/arbitration/Arbitrator.java
View file

@ -29,7 +29,6 @@ import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
import javax.annotation.Nullable;
import java.nio.charset.Charset;
import java.security.PublicKey;
import java.util.Date;
import java.util.List;
@ -44,18 +43,18 @@ import java.util.stream.Collectors;
@Getter
public final class Arbitrator implements StoragePayload {
public static final long TTL = TimeUnit.DAYS.toMillis(10);
// Payload
private final byte[] btcPubKey;
private final PubKeyRing pubKeyRing;
private final NodeAddress nodeAddress;
private final List<String> languageCodes;
private final byte[] btcPubKey;
private final String btcAddress;
private final PubKeyRing pubKeyRing;
private final List<String> languageCodes;
private final long registrationDate;
private final String registrationSignature;
private final byte[] registrationPubKey;
private final String registrationSignature;
@Nullable
private final String emailAddress;
@Nullable
private final String info;
// Should be only used in emergency case if we need to add data but do not want to break backward compatibility
// at the P2P network storage checks. The hash of the object will be used to verify if the data is valid. Any new
@ -63,7 +62,6 @@ public final class Arbitrator implements StoragePayload {
@Nullable
private Map<String, String> extraDataMap;
// Called from domain and PB
public Arbitrator(NodeAddress nodeAddress,
byte[] btcPubKey,
String btcAddress,
@ -73,22 +71,54 @@ public final class Arbitrator implements StoragePayload {
byte[] registrationPubKey,
String registrationSignature,
@Nullable String emailAddress,
@Nullable String info,
@Nullable Map<String, String> extraDataMap) {
this.nodeAddress = nodeAddress;
this.btcPubKey = btcPubKey;
this.btcAddress = btcAddress;
this.pubKeyRing = pubKeyRing;
this.languageCodes = languageCodes;
this.emailAddress = emailAddress;
this.registrationDate = registrationDate.getTime();
this.registrationPubKey = registrationPubKey;
this.registrationSignature = registrationSignature;
this.emailAddress = emailAddress;
this.info = info;
this.extraDataMap = extraDataMap;
}
///////////////////////////////////////////////////////////////////////////////////////////
// PROTO BUFFER
///////////////////////////////////////////////////////////////////////////////////////////
@Override
public long getTTL() {
return TTL;
public PB.StoragePayload toProtoMessage() {
final PB.Arbitrator.Builder builder = PB.Arbitrator.newBuilder()
.setNodeAddress(nodeAddress.toProtoMessage())
.setBtcPubKey(ByteString.copyFrom(btcPubKey))
.setBtcAddress(btcAddress)
.setPubKeyRing(pubKeyRing.toProtoMessage())
.addAllLanguageCodes(languageCodes)
.setRegistrationDate(registrationDate)
.setRegistrationPubKey(ByteString.copyFrom(registrationPubKey))
.setRegistrationSignature(registrationSignature);
Optional.ofNullable(emailAddress).ifPresent(builder::setEmailAddress);
Optional.ofNullable(info).ifPresent(builder::setInfo);
Optional.ofNullable(extraDataMap).ifPresent(builder::putAllExtraData);
return PB.StoragePayload.newBuilder().setArbitrator(builder).build();
}
public static Arbitrator fromProto(PB.Arbitrator proto) {
return new Arbitrator(NodeAddress.fromProto(proto.getNodeAddress()),
proto.getBtcPubKey().toByteArray(),
proto.getBtcAddress(),
PubKeyRing.fromProto(proto.getPubKeyRing()),
proto.getLanguageCodesList().stream().collect(Collectors.toList()),
new Date(proto.getRegistrationDate()),
proto.getRegistrationPubKey().toByteArray(),
proto.getRegistrationSignature(),
proto.getEmailAddress().isEmpty() ? null : proto.getEmailAddress(),
proto.getInfo().isEmpty() ? null : proto.getInfo(),
CollectionUtils.isEmpty(proto.getExtraDataMap()) ? null : proto.getExtraDataMap());
}
@Override
@ -97,36 +127,7 @@ public final class Arbitrator implements StoragePayload {
}
@Override
public PB.StoragePayload toProtoMessage() {
final PB.Arbitrator.Builder builder = PB.Arbitrator.newBuilder()
.setBtcPubKey(ByteString.copyFrom(btcPubKey))
.setPubKeyRing(pubKeyRing.toProtoMessage())
.setNodeAddress(nodeAddress.toProtoMessage())
.addAllLanguageCodes(languageCodes)
.setBtcAddress(btcAddress)
.setRegistrationDate(registrationDate)
.setRegistrationSignature(ByteString.copyFrom(registrationSignature.getBytes())) // string does not conform to UTF-8 !
.setRegistrationPubKey(ByteString.copyFrom(registrationPubKey));
Optional.ofNullable(extraDataMap).ifPresent(builder::putAllExtraDataMap);
Optional.ofNullable(emailAddress).ifPresent(builder::setEmailAddress);
return PB.StoragePayload.newBuilder().setArbitrator(builder).build();
public long getTTL() {
return TTL;
}
public static Arbitrator fromProto(PB.Arbitrator arbitrator) {
List<String> strings = arbitrator.getLanguageCodesList().stream().collect(Collectors.toList());
Date date = new Date(arbitrator.getRegistrationDate());
String emailAddress = arbitrator.getEmailAddress().isEmpty() ? null : arbitrator.getEmailAddress();
return new Arbitrator(NodeAddress.fromProto(arbitrator.getNodeAddress()),
arbitrator.getBtcPubKey().toByteArray(),
arbitrator.getBtcAddress(),
PubKeyRing.fromProto(arbitrator.getPubKeyRing()),
strings,
date,
arbitrator.getRegistrationPubKey().toByteArray(),
arbitrator.getRegistrationSignature().toString(Charset.forName("UTF-8")), // convert back to String
emailAddress,
CollectionUtils.isEmpty(arbitrator.getExtraDataMapMap()) ?
null : arbitrator.getExtraDataMapMap());
}
}

6
core/src/main/java/io/bisq/core/arbitration/Dispute.java
View file

@ -30,7 +30,6 @@ import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.ToString;
import lombok.extern.slf4j.Slf4j;
import org.bouncycastle.util.encoders.Hex;
@ -42,7 +41,6 @@ import java.util.stream.Collectors;
@Slf4j
@EqualsAndHashCode
@ToString
@Getter
public final class Dispute implements NetworkPayload {
private final String tradeId;
@ -50,7 +48,6 @@ public final class Dispute implements NetworkPayload {
private final int traderId;
private final boolean disputeOpenerIsBuyer;
private final boolean disputeOpenerIsMaker;
private long openingDate;
private final PubKeyRing traderPubKeyRing;
private final long tradeDate;
private final Contract contract;
@ -78,6 +75,8 @@ public final class Dispute implements NetworkPayload {
@Nullable
private String disputePayoutTxId;
private long openingDate;
transient private Storage<DisputeList> storage;
transient private ObservableList<DisputeCommunicationMessage> observableList;
transient private BooleanProperty isClosedProperty;
@ -125,6 +124,7 @@ public final class Dispute implements NetworkPayload {
isSupportTicket);
openingDate = new Date().getTime();
this.storage = storage;
}

69
core/src/main/java/io/bisq/core/arbitration/Mediator.java
View file

@ -42,10 +42,7 @@ import java.util.stream.Collectors;
@ToString
@Getter
public final class Mediator implements StoragePayload {
public static final long TTL = TimeUnit.DAYS.toMillis(10);
// Payload
private final long TTL = TimeUnit.DAYS.toMillis(10);
private final PubKeyRing pubKeyRing;
private final NodeAddress nodeAddress;
private final List<String> languageCodes;
@ -76,54 +73,44 @@ public final class Mediator implements StoragePayload {
this.nodeAddress = nodeAddress;
this.pubKeyRing = pubKeyRing;
this.languageCodes = languageCodes;
this.emailAddress = emailAddress;
this.info = info;
this.registrationDate = registrationDate.getTime();
this.registrationPubKey = registrationPubKey;
this.registrationSignature = registrationSignature;
this.emailAddress = emailAddress;
this.info = info;
this.extraDataMap = extraDataMap;
}
@Override
public long getTTL() {
return TTL;
public PB.StoragePayload toProtoMessage() {
final PB.Mediator.Builder builder = PB.Mediator.newBuilder()
.setNodeAddress(nodeAddress.toProtoMessage())
.setPubKeyRing(pubKeyRing.toProtoMessage())
.addAllLanguageCodes(languageCodes)
.setRegistrationDate(registrationDate)
.setRegistrationPubKey(ByteString.copyFrom(registrationPubKey))
.setRegistrationSignature(registrationSignature);
Optional.ofNullable(emailAddress).ifPresent(builder::setEmailAddress);
Optional.ofNullable(info).ifPresent(builder::setInfo);
Optional.ofNullable(extraDataMap).ifPresent(builder::putAllExtraData);
return PB.StoragePayload.newBuilder().setMediator(builder).build();
}
public static Mediator fromProto(PB.Mediator proto) {
return new Mediator(NodeAddress.fromProto(proto.getNodeAddress()),
PubKeyRing.fromProto(proto.getPubKeyRing()),
proto.getLanguageCodesList().stream().collect(Collectors.toList()),
new Date(proto.getRegistrationDate()),
proto.getRegistrationPubKey().toByteArray(),
proto.getRegistrationSignature(),
proto.getEmailAddress().isEmpty() ? null : proto.getEmailAddress(),
proto.getInfo().isEmpty() ? null : proto.getInfo(),
CollectionUtils.isEmpty(proto.getExtraDataMap()) ? null : proto.getExtraDataMap());
}
@Override
public PublicKey getOwnerPubKey() {
return pubKeyRing.getSignaturePubKey();
}
@Override
public PB.StoragePayload toProtoMessage() {
final PB.Mediator.Builder builder = PB.Mediator.newBuilder()
.setPubKeyRing(pubKeyRing.toProtoMessage())
.setNodeAddress(nodeAddress.toProtoMessage())
.addAllLanguageCodes(languageCodes)
.setRegistrationDate(registrationDate)
.setRegistrationSignature(registrationSignature)
.setRegistrationPubKey(ByteString.copyFrom(registrationPubKey));
Optional.ofNullable(extraDataMap).ifPresent(builder::putAllExtraDataMap);
Optional.ofNullable(emailAddress).ifPresent(builder::setEmailAddress);
Optional.ofNullable(info).ifPresent(builder::setInfo);
return PB.StoragePayload.newBuilder().setMediator(builder).build();
}
public static Mediator fromProto(PB.Mediator mediator) {
List<String> langCodes = mediator.getLanguageCodesList().stream().collect(Collectors.toList());
Date date = new Date(mediator.getRegistrationDate());
String emailAddress = mediator.getEmailAddress().isEmpty() ? null : mediator.getEmailAddress();
return new Mediator(NodeAddress.fromProto(mediator.getNodeAddress()),
PubKeyRing.fromProto(mediator.getPubKeyRing()),
langCodes,
date,
mediator.getRegistrationPubKey().toByteArray(),
mediator.getRegistrationSignature(),
emailAddress,
mediator.getInfo(),
CollectionUtils.isEmpty(mediator.getExtraDataMapMap()) ?
null : mediator.getExtraDataMapMap());
}
}

120
core/src/main/java/io/bisq/core/dao/compensation/CompensationRequestPayload.java
View file

@ -43,25 +43,22 @@ import java.util.concurrent.TimeUnit;
@Data
// TODO There will be another object for PersistableEnvelope
public final class CompensationRequestPayload implements LazyProcessedStoragePayload, PersistedStoragePayload, PersistableEnvelope {
public static final long TTL = TimeUnit.DAYS.toMillis(30);
private final byte version;
private final long creationDate;
private final long TTL = TimeUnit.DAYS.toMillis(30);
private final String uid;
private final String name;
private final String title;
private final String category;
private final String description;
private final String link;
public final long startDate;
public final long endDate;
private final long startDate;
private final long endDate;
private final long requestedBtc;
private final String btcAddress;
private final String nodeAddress;
@JsonExclude
private final byte[] p2pStorageSignaturePubKeyBytes;
private final byte[] ownerPubKeyBytes;
// used for json
private String p2pStorageSignaturePubKeyAsHex;
private String ownerPubPubKeyAsHex;
// Signature of the JSON data of this object excluding the signature and feeTxId fields using the standard Bitcoin
// messaging signing format as a base64 encoded string.
@JsonExclude
@ -75,12 +72,12 @@ public final class CompensationRequestPayload implements LazyProcessedStoragePay
@Nullable
private Map<String, String> extraDataMap;
private final byte version;
private final long creationDate;
// Domain
@JsonExclude
private transient PublicKey ownerPubKey;
// Called from domain
public CompensationRequestPayload(String uid,
String name,
String title,
@ -92,7 +89,7 @@ public final class CompensationRequestPayload implements LazyProcessedStoragePay
Coin requestedBtc,
String btcAddress,
NodeAddress nodeAddress,
PublicKey p2pStorageSignaturePubKey) {
PublicKey ownerPubKey) {
this(uid,
name,
title,
@ -104,12 +101,16 @@ public final class CompensationRequestPayload implements LazyProcessedStoragePay
requestedBtc,
btcAddress,
nodeAddress.getFullAddress(),
Sig.getSigPublicKeyBytes(p2pStorageSignaturePubKey),
Sig.getSigPublicKeyBytes(ownerPubKey),
null);
}
// Called from PB
public CompensationRequestPayload(String uid,
///////////////////////////////////////////////////////////////////////////////////////////
// PROTO BUFFER
///////////////////////////////////////////////////////////////////////////////////////////
private CompensationRequestPayload(String uid,
String name,
String title,
String category,
@ -120,12 +121,8 @@ public final class CompensationRequestPayload implements LazyProcessedStoragePay
Coin requestedBtc,
String btcAddress,
String nodeAddress,
byte[] p2pStorageSignaturePubKeyBytes,
byte[] ownerPubKeyBytes,
@Nullable Map<String, String> extraDataMap) {
version = Version.COMPENSATION_REQUEST_VERSION;
creationDate = new Date().getTime();
this.uid = uid;
this.name = name;
this.title = title;
@ -137,19 +134,57 @@ public final class CompensationRequestPayload implements LazyProcessedStoragePay
this.requestedBtc = requestedBtc.value;
this.btcAddress = btcAddress;
this.nodeAddress = nodeAddress;
this.p2pStorageSignaturePubKeyBytes = p2pStorageSignaturePubKeyBytes;
this.ownerPubKeyBytes = ownerPubKeyBytes;
this.extraDataMap = extraDataMap;
ownerPubKey = Sig.getSigPublicKeyFromBytes(p2pStorageSignaturePubKeyBytes);
p2pStorageSignaturePubKeyAsHex = Utils.HEX.encode(ownerPubKey.getEncoded());
version = Version.COMPENSATION_REQUEST_VERSION;
creationDate = new Date().getTime();
this.ownerPubKey = Sig.getSigPublicKeyFromBytes(ownerPubKeyBytes);
ownerPubPubKeyAsHex = Utils.HEX.encode(this.ownerPubKey.getEncoded());
}
@Override
public long getTTL() {
return TTL;
public PB.StoragePayload toProtoMessage() {
final PB.CompensationRequestPayload.Builder builder = PB.CompensationRequestPayload.newBuilder()
.setUid(uid)
.setName(name)
.setTitle(title)
.setCategory(category)
.setDescription(description)
.setLink(link)
.setStartDate(startDate)
.setEndDate(endDate)
.setRequestedBtc(requestedBtc)
.setBtcAddress(btcAddress)
.setNodeAddress(nodeAddress)
.setOwnerPubKeyAsHex(ownerPubPubKeyAsHex)
.setSignature(signature)
.setFeeTxId(feeTxId)
.setVersion(version)
.setCreationDate(creationDate);
Optional.ofNullable(extraDataMap).ifPresent(builder::putAllExtraData);
return PB.StoragePayload.newBuilder().setCompensationRequestPayload(builder).build();
}
public static CompensationRequestPayload fromProto(PB.CompensationRequestPayload proto) {
return new CompensationRequestPayload(proto.getUid(),
proto.getName(),
proto.getTitle(),
proto.getCategory(),
proto.getDescription(), proto.getLink(),
new Date(proto.getStartDate()),
new Date(proto.getEndDate()),
Coin.valueOf(proto.getRequestedBtc()),
proto.getBtcAddress(),
proto.getNodeAddress(), proto.getOwnerPubKeyBytes().toByteArray(),
CollectionUtils.isEmpty(proto.getExtraDataMap()) ? null : proto.getExtraDataMap());
}
///////////////////////////////////////////////////////////////////////////////////////////
// Getters
///////////////////////////////////////////////////////////////////////////////////////////
public Date getStartDate() {
return new Date(startDate);
}
@ -174,37 +209,6 @@ public final class CompensationRequestPayload implements LazyProcessedStoragePay
return uid.substring(0, 8);
}
@Override
public PB.StoragePayload toProtoMessage() {
final PB.CompensationRequestPayload.Builder builder = PB.CompensationRequestPayload.newBuilder()
.setVersion(version)
.setCreationDate(creationDate)
.setUid(uid)
.setName(name)
.setTitle(title)
.setCategory(category)
.setDescription(description)
.setLink(link)
.setStartDate(startDate)
.setEndDate(endDate)
.setRequestedBtc(requestedBtc)
.setBtcAddress(btcAddress)
.setNodeAddress(nodeAddress)
.setP2PStorageSignaturePubKeyAsHex(p2pStorageSignaturePubKeyAsHex)
.setSignature(signature)
.setFeeTxId(feeTxId);
Optional.ofNullable(extraDataMap).ifPresent(builder::putAllExtraDataMap);
return PB.StoragePayload.newBuilder().setCompensationRequestPayload(builder).build();
}
public static CompensationRequestPayload fromProto(PB.CompensationRequestPayload proto) {
return new CompensationRequestPayload(proto.getUid(), proto.getName(), proto.getTitle(), proto.getCategory(),
proto.getDescription(), proto.getLink(), new Date(proto.getStartDate()), new Date(proto.getEndDate()),
Coin.valueOf(proto.getRequestedBtc()), proto.getBtcAddress(),
proto.getNodeAddress(), proto.getP2PStorageSignaturePubKeyBytes().toByteArray(),
CollectionUtils.isEmpty(proto.getExtraDataMapMap()) ? null : proto.getExtraDataMapMap());
}
@Override
public String toString() {
return "CompensationRequestPayload{" +
@ -221,8 +225,8 @@ public final class CompensationRequestPayload implements LazyProcessedStoragePay
", requestedBtc=" + requestedBtc +
", btcAddress='" + btcAddress + '\'' +
", nodeAddress='" + getNodeAddress() + '\'' +
", p2pStorageSignaturePubKeyBytes=" + Hex.toHexString(p2pStorageSignaturePubKeyBytes) +
", p2pStorageSignaturePubKeyAsHex='" + p2pStorageSignaturePubKeyAsHex + '\'' +
", p2pStorageSignaturePubKeyBytes=" + Hex.toHexString(ownerPubKeyBytes) +
", p2pStorageSignaturePubKeyAsHex='" + ownerPubPubKeyAsHex + '\'' +
", signature='" + signature + '\'' +
", feeTxId='" + feeTxId + '\'' +
", extraDataMap=" + extraDataMap +

86
core/src/main/java/io/bisq/core/dao/vote/VoteItem.java
View file

@ -19,6 +19,9 @@ package io.bisq.core.dao.vote;
import io.bisq.common.proto.persistable.PersistablePayload;
import io.bisq.generated.protobuffer.PB;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.ToString;
import lombok.extern.slf4j.Slf4j;
import javax.annotation.Nullable;
@ -28,60 +31,32 @@ import static com.google.common.base.Preconditions.checkArgument;
//TODO if sent over wire make final
@Slf4j
@Getter
@ToString
@EqualsAndHashCode
public class VoteItem implements PersistablePayload {
// public final String version;
public final VotingType votingType;
private final VotingType votingType;
@Nullable
public final String name;
public final long defaultValue;
protected boolean hasVoted;
public byte getValue() {
return value;
}
private final String name;
private final long defaultValue;
private byte value;
public VoteItem(VotingType votingType, @Nullable String name, byte value, @Nullable VotingDefaultValues votingDefaultValues) {
this.votingType = votingType;
this.name = name;
this.value = value;
this.defaultValue = votingDefaultValues != null ? votingDefaultValues.getValueByVotingType(votingType) : 0;
}
private boolean hasVoted;
public VoteItem(VotingType votingType, String name, VotingDefaultValues votingDefaultValues) {
this(votingType, name, (byte) 0x00, votingDefaultValues);
}
public long getAdjustedValue(long originalValue, int change) {
checkArgument(change < 255 && change > -1,
"Range for change can be 0 to 254. 255 is not supported as we want a 0 value in the middle");
double fact = (change - 127) / 127d;
return (long) (originalValue * Math.pow(10, fact));
}
// We return the change parameter (0-254)
public int getChange(long originalValue, long newValue) {
return (int) Math.round(Math.log10((double) newValue / (double) originalValue) * 127 + 127);
}
///////////////////////////////////////////////////////////////////////////////////////////
// PROTO BUFFER
///////////////////////////////////////////////////////////////////////////////////////////
public void setValue(byte value) {
private VoteItem(VotingType votingType, @Nullable String name, byte value, @Nullable VotingDefaultValues votingDefaultValues) {
this.votingType = votingType;
this.name = name;
this.value = value;
this.hasVoted = true;
}
public boolean hasVoted() {
return hasVoted;
}
@Override
public String toString() {
return "VoteItem{" +
"code=" + votingType +
", name='" + name + '\'' +
", value=" + value +
'}';
this.defaultValue = votingDefaultValues != null ? votingDefaultValues.getValueByVotingType(votingType) : 0;
}
@Override
@ -99,6 +74,31 @@ public class VoteItem implements PersistablePayload {
VotingDefaultValues defaultValues = new VotingDefaultValues();
VotingType votingType = VotingType.valueOf(voteItem.getVotingType().name());
defaultValues.setValueByVotingType(votingType, voteItem.getValue());
return new VoteItem(votingType, voteItem.getName(), (byte) voteItem.getValue(), defaultValues);
return new VoteItem(votingType,
voteItem.getName(),
(byte) voteItem.getValue(),
defaultValues);
}
///////////////////////////////////////////////////////////////////////////////////////////
// API
///////////////////////////////////////////////////////////////////////////////////////////
public long getAdjustedValue(long originalValue, int change) {
checkArgument(change < 255 && change > -1,
"Range for change can be 0 to 254. 255 is not supported as we want a 0 value in the middle");
double fact = (change - 127) / 127d;
return (long) (originalValue * Math.pow(10, fact));
}
// We return the change parameter (0-254)
public int getChange(long originalValue, long newValue) {
return (int) Math.round(Math.log10((double) newValue / (double) originalValue) * 127 + 127);
}
public void setValue(byte value) {
this.value = value;
this.hasVoted = true;
}
}

2
core/src/main/java/io/bisq/core/dao/vote/VoteItemsList.java
View file

@ -99,7 +99,7 @@ public final class VoteItemsList implements PersistablePayload {
}
public Optional<VoteItem> getVoteItemByVotingType(VotingType votingType) {
return allVoteItemList.stream().filter(e -> e.votingType == votingType).findAny();
return allVoteItemList.stream().filter(e -> e.getVotingType() == votingType).findAny();
}
// TODO not impl yet

2
core/src/main/java/io/bisq/core/dao/vote/VotingManager.java
View file

@ -266,7 +266,7 @@ public class VotingManager {
items.stream().forEach(paramItem -> {
checkArgument(outputStream.size() % 2 == 0,
"Position of writing code must be at even index.");
outputStream.write(paramItem.votingType.code);
outputStream.write(paramItem.getVotingType().code);
byte value = paramItem.getValue();
outputStream.write(value);
});

101
core/src/main/java/io/bisq/core/filter/Filter.java
View file

@ -17,17 +17,14 @@
package io.bisq.core.filter;
import com.google.common.collect.Maps;
import com.google.protobuf.ByteString;
import io.bisq.common.crypto.Sig;
import io.bisq.core.proto.ProtoUtil;
import io.bisq.generated.protobuffer.PB;
import io.bisq.network.p2p.storage.payload.StoragePayload;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.ToString;
import lombok.extern.slf4j.Slf4j;
import org.bouncycastle.util.encoders.Hex;
import org.springframework.util.CollectionUtils;
import javax.annotation.Nullable;
@ -38,17 +35,18 @@ import java.util.Optional;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import static com.google.common.base.Preconditions.checkNotNull;
@Slf4j
@Getter
@EqualsAndHashCode
@ToString
public final class Filter implements StoragePayload {
private static final long TTL = TimeUnit.DAYS.toMillis(21);
private final long TTL = TimeUnit.DAYS.toMillis(21);
private final List<String> bannedOfferIds;
private final List<String> bannedNodeAddress;
private final List<PaymentAccountFilter> bannedPaymentAccounts;
public final List<String> bannedNodeAddress;
public final List<String> bannedOfferIds;
public final List<PaymentAccountFilter> bannedPaymentAccounts;
private String signatureAsBase64;
private byte[] ownerPubKeyBytes;
// Should be only used in emergency case if we need to add data but do not want to break backward compatibility
@ -64,16 +62,22 @@ public final class Filter implements StoragePayload {
this.bannedOfferIds = bannedOfferIds;
this.bannedNodeAddress = bannedNodeAddress;
this.bannedPaymentAccounts = bannedPaymentAccounts;
this.extraDataMap = Maps.newHashMap();
}
///////////////////////////////////////////////////////////////////////////////////////////
// PROTO BUFFER
///////////////////////////////////////////////////////////////////////////////////////////
public Filter(List<String> bannedOfferIds,
List<String> bannedNodeAddress,
List<PaymentAccountFilter> bannedPaymentAccounts,
String signatureAsBase64,
byte[] ownerPubKeyBytes,
@Nullable Map<String, String> extraDataMap) {
this(bannedOfferIds, bannedNodeAddress, bannedPaymentAccounts);
this(bannedOfferIds,
bannedNodeAddress,
bannedPaymentAccounts);
this.signatureAsBase64 = signatureAsBase64;
this.ownerPubKeyBytes = ownerPubKeyBytes;
this.extraDataMap = extraDataMap;
@ -81,55 +85,44 @@ public final class Filter implements StoragePayload {
ownerPubKey = Sig.getSigPublicKeyFromBytes(ownerPubKeyBytes);
}
@Override
public PB.StoragePayload toProtoMessage() {
checkNotNull(signatureAsBase64, "signatureAsBase64 must nto be null");
checkNotNull(ownerPubKeyBytes, "ownerPubKeyBytes must nto be null");
List<PB.PaymentAccountFilter> paymentAccountFilterList = bannedPaymentAccounts.stream()
.map(PaymentAccountFilter::toProtoMessage)
.collect(Collectors.toList());
final PB.Filter.Builder builder = PB.Filter.newBuilder()
.addAllBannedOfferIds(bannedOfferIds)
.addAllBannedNodeAddress(bannedNodeAddress)
.addAllBannedPaymentAccounts(paymentAccountFilterList)
.setSignatureAsBase64(signatureAsBase64)
.setOwnerPubKeyBytes(ByteString.copyFrom(ownerPubKeyBytes));
Optional.ofNullable(extraDataMap).ifPresent(builder::putAllExtraData);
return PB.StoragePayload.newBuilder().setFilter(builder).build();
}
public static Filter fromProto(PB.Filter proto) {
return new Filter(proto.getBannedOfferIdsList().stream().collect(Collectors.toList()),
proto.getBannedNodeAddressList().stream().collect(Collectors.toList()),
proto.getBannedPaymentAccountsList()
.stream()
.map(PaymentAccountFilter::fromProto)
.collect(Collectors.toList()),
proto.getSignatureAsBase64(),
proto.getOwnerPubKeyBytes().toByteArray(),
CollectionUtils.isEmpty(proto.getExtraDataMap()) ? null : proto.getExtraDataMap());
}
///////////////////////////////////////////////////////////////////////////////////////////
// API
///////////////////////////////////////////////////////////////////////////////////////////
public void setSigAndPubKey(String signatureAsBase64, PublicKey ownerPubKey) {
this.signatureAsBase64 = signatureAsBase64;
this.ownerPubKey = ownerPubKey;
ownerPubKeyBytes = Sig.getSigPublicKeyBytes(this.ownerPubKey);
}
@Override
public long getTTL() {
return TTL;
}
@Override
public PB.StoragePayload toProtoMessage() {
List<PB.PaymentAccountFilter> paymentAccountFilterList;
paymentAccountFilterList = bannedPaymentAccounts.stream()
.map(PaymentAccountFilter::toProtoBuf).collect(Collectors.toList());
final PB.Filter.Builder builder = PB.Filter.newBuilder()
.addAllBannedNodeAddress(bannedNodeAddress)
.addAllBannedOfferIds(bannedOfferIds)
.addAllBannedPaymentAccounts(paymentAccountFilterList)
.setSignatureAsBase64(signatureAsBase64)
.setOwnerPubKeyBytes(ByteString.copyFrom(ownerPubKeyBytes));
Optional.ofNullable(extraDataMap).ifPresent(builder::putAllExtraDataMap);
return PB.StoragePayload.newBuilder().setFilter(builder).build();
}
public static Filter fromProto(PB.Filter filter) {
List<PaymentAccountFilter> paymentAccountFilters = filter.getBannedPaymentAccountsList()
.stream().map(accountFilter -> ProtoUtil.getPaymentAccountFilter(accountFilter)).collect(Collectors.toList());
return new Filter(filter.getBannedOfferIdsList().stream().collect(Collectors.toList()),
filter.getBannedNodeAddressList().stream().collect(Collectors.toList()),
paymentAccountFilters,
filter.getSignatureAsBase64(),
filter.getOwnerPubKeyBytes().toByteArray(),
CollectionUtils.isEmpty(filter.getExtraDataMapMap()) ?
null : filter.getExtraDataMapMap());
}
@Override
public String toString() {
return "Filter{" +
"bannedNodeAddress=" + bannedNodeAddress +
", bannedOfferIds=" + bannedOfferIds +
", bannedPaymentAccounts=" + bannedPaymentAccounts +
", signatureAsBase64='" + signatureAsBase64 + '\'' +
", publicKey=" + Hex.toHexString(ownerPubKey.getEncoded()) +
", extraDataMap=" + extraDataMap +
'}';
}
}

8
core/src/main/java/io/bisq/core/filter/FilterManager.java
View file

@ -162,10 +162,10 @@ public class FilterManager {
}
private String getHexFromData(Filter filter) {
PB.Filter.Builder builder = PB.Filter.newBuilder().addAllBannedNodeAddress(filter.bannedNodeAddress)
.addAllBannedOfferIds(filter.bannedOfferIds)
.addAllBannedPaymentAccounts(filter.bannedPaymentAccounts.stream()
.map(PaymentAccountFilter::toProtoBuf)
PB.Filter.Builder builder = PB.Filter.newBuilder().addAllBannedNodeAddress(filter.getBannedNodeAddress())
.addAllBannedOfferIds(filter.getBannedOfferIds())
.addAllBannedPaymentAccounts(filter.getBannedPaymentAccounts().stream()
.map(PaymentAccountFilter::toProtoMessage)
.collect(Collectors.toList()));
return Utils.HEX.encode(builder.build().toByteArray());
}

29
core/src/main/java/io/bisq/core/filter/PaymentAccountFilter.java
View file

@ -1,19 +1,16 @@
package io.bisq.core.filter;
import io.bisq.common.proto.network.NetworkPayload;
import io.bisq.generated.protobuffer.PB;
import lombok.ToString;
import lombok.Value;
import lombok.extern.slf4j.Slf4j;
import java.io.Serializable;
@ToString
@Value
@Slf4j
public class PaymentAccountFilter implements Serializable {
// Payload
public final String paymentMethodId;
public final String getMethodName;
public final String value;
public class PaymentAccountFilter implements NetworkPayload {
private final String paymentMethodId;
private final String getMethodName;
private final String value;
public PaymentAccountFilter(String paymentMethodId, String getMethodName, String value) {
this.paymentMethodId = paymentMethodId;
@ -21,10 +18,18 @@ public class PaymentAccountFilter implements Serializable {
this.value = value;
}
public PB.PaymentAccountFilter toProtoBuf() {
@Override
public PB.PaymentAccountFilter toProtoMessage() {
return PB.PaymentAccountFilter.newBuilder()
.setPaymentMethodId(paymentMethodId)
.setGetMethodName(getMethodName)
.setValue(value).build();
.setValue(value)
.build();
}
public static PaymentAccountFilter fromProto(PB.PaymentAccountFilter proto) {
return new PaymentAccountFilter(proto.getPaymentMethodId(),
proto.getGetMethodName(),
proto.getValue());
}
}

26
core/src/main/java/io/bisq/core/offer/Offer.java
View file

@ -86,6 +86,21 @@ public class Offer implements NetworkPayload, PersistablePayload {
this.offerPayload = offerPayload;
}
///////////////////////////////////////////////////////////////////////////////////////////
// PROTO BUFFER
///////////////////////////////////////////////////////////////////////////////////////////
@Override
public PB.Offer toProtoMessage() {
return PB.Offer.newBuilder().setOfferPayload(offerPayload.toProtoMessage().getOfferPayload()).build();
}
public static Offer fromProto(PB.Offer proto) {
return new Offer(OfferPayload.fromProto(proto.getOfferPayload()));
}
///////////////////////////////////////////////////////////////////////////////////////////
// Availability
///////////////////////////////////////////////////////////////////////////////////////////
@ -364,7 +379,7 @@ public class Offer implements NetworkPayload, PersistablePayload {
}
public NodeAddress getMakerNodeAddress() {
return offerPayload.getMakerNodeAddress();
return offerPayload.getOwnerNodeAddress();
}
public PubKeyRing getPubKeyRing() {
@ -459,13 +474,4 @@ public class Offer implements NetworkPayload, PersistablePayload {
", offerPayload=" + offerPayload +
'}';
}
@Override
public PB.Offer toProtoMessage() {
return PB.Offer.newBuilder().setOfferPayload(offerPayload.toProtoMessage().getOfferPayload()).build();
}
public static Offer fromProto(PB.Offer proto) {
return new Offer(OfferPayload.fromProto(proto.getOfferPayload()));
}
}

168
core/src/main/java/io/bisq/core/offer/OfferPayload.java
View file

@ -17,7 +17,6 @@
package io.bisq.core.offer;
import io.bisq.common.app.DevEnv;
import io.bisq.common.app.Version;
import io.bisq.common.crypto.PubKeyRing;
import io.bisq.common.locale.CurrencyUtil;
@ -42,30 +41,30 @@ import java.util.Optional;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import static com.google.common.base.Preconditions.checkArgument;
@ToString
@EqualsAndHashCode
@Getter
@Slf4j
public final class OfferPayload implements StoragePayload, RequiresOwnerIsOnlinePayload {
public static final long TTL = TimeUnit.MINUTES.toMillis(DevEnv.STRESS_TEST_MODE ? 6 : 6);
///////////////////////////////////////////////////////////////////////////////////////////
// Enums
///////////////////////////////////////////////////////////////////////////////////////////
public enum Direction {
BUY, SELL;
public static OfferPayload.Direction fromProto(PB.OfferPayload.Direction direction) {
return OfferPayload.Direction.valueOf(direction.name());
}
public static PB.OfferPayload.Direction toProtoMessage(Direction direction) {
return PB.OfferPayload.Direction.valueOf(direction.name());
}
}
///////////////////////////////////////////////////////////////////////////////////////////
// Instance fields
///////////////////////////////////////////////////////////////////////////////////////////
private final long TTL = TimeUnit.MINUTES.toMillis(6);
private final Direction direction;
private final String baseCurrencyCode;
private final String counterCurrencyCode;
@ -82,7 +81,6 @@ public final class OfferPayload implements StoragePayload, RequiresOwnerIsOnline
private final List<NodeAddress> mediatorNodeAddresses;
private final String id;
private final long date;
private final long protocolVersion;
// We use 2 type of prices: fixed price or price based on distance from market price
private final boolean useMarketBasedPrice;
@ -97,7 +95,7 @@ public final class OfferPayload implements StoragePayload, RequiresOwnerIsOnline
private final double marketPriceMargin;
private final long amount;
private final long minAmount;
private final NodeAddress makerNodeAddress;
private final NodeAddress ownerNodeAddress;
@JsonExclude
private final PubKeyRing pubKeyRing;
private final String makerPaymentAccountId;
@ -136,7 +134,8 @@ public final class OfferPayload implements StoragePayload, RequiresOwnerIsOnline
// at the P2P network storage checks. The hash of the object will be used to verify if the data is valid. Any new
// field in a class would break that hash and therefore break the storage mechanism.
@Nullable
private Map<String, String> extraDataMap;
private final Map<String, String> extraDataMap;
private final long protocolVersion;
///////////////////////////////////////////////////////////////////////////////////////////
@ -145,7 +144,7 @@ public final class OfferPayload implements StoragePayload, RequiresOwnerIsOnline
public OfferPayload(String id,
long date,
NodeAddress makerNodeAddress,
NodeAddress ownerNodeAddress,
PubKeyRing pubKeyRing,
Direction direction,
long price,
@ -183,7 +182,7 @@ public final class OfferPayload implements StoragePayload, RequiresOwnerIsOnline
this.id = id;
this.date = date;
this.makerNodeAddress = makerNodeAddress;
this.ownerNodeAddress = ownerNodeAddress;
this.pubKeyRing = pubKeyRing;
this.direction = direction;
this.price = price;
@ -219,38 +218,7 @@ public final class OfferPayload implements StoragePayload, RequiresOwnerIsOnline
this.hashOfChallenge = hashOfChallenge;
this.extraDataMap = extraDataMap;
this.protocolVersion = Version.TRADE_PROTOCOL_VERSION;
}
///////////////////////////////////////////////////////////////////////////////////////////
// Overridden Getters
///////////////////////////////////////////////////////////////////////////////////////////
@Override
public NodeAddress getOwnerNodeAddress() {
return makerNodeAddress;
}
@Override
public PublicKey getOwnerPubKey() {
return pubKeyRing.getSignaturePubKey();
}
@Override
public long getTTL() {
return TTL;
}
//TODO remove
public String getCurrencyCode() {
if (CurrencyUtil.isCryptoCurrency(getBaseCurrencyCode()))
return getBaseCurrencyCode();
else
return getCounterCurrencyCode();
protocolVersion = Version.TRADE_PROTOCOL_VERSION;
}
@ -260,29 +228,26 @@ public final class OfferPayload implements StoragePayload, RequiresOwnerIsOnline
@Override
public PB.StoragePayload toProtoMessage() {
List<PB.NodeAddress> arbitratorNodeAddresses = this.arbitratorNodeAddresses.stream()
.map(NodeAddress::toProtoMessage)
.collect(Collectors.toList());
List<PB.NodeAddress> mediatorNodeAddresses = this.mediatorNodeAddresses.stream()
.map(NodeAddress::toProtoMessage)
.collect(Collectors.toList());
PB.OfferPayload.Builder offerBuilder = PB.OfferPayload.newBuilder()
.setDirection(PB.OfferPayload.Direction.valueOf(direction.name()))
.setBaseCurrencyCode(baseCurrencyCode)
.setCounterCurrencyCode(counterCurrencyCode)
.setPaymentMethodId(paymentMethodId)
.addAllArbitratorNodeAddresses(arbitratorNodeAddresses)
.addAllMediatorNodeAddresses(mediatorNodeAddresses)
PB.OfferPayload.Builder builder = PB.OfferPayload.newBuilder()
.setId(id)
.setDate(date)
.setProtocolVersion(protocolVersion)
.setUseMarketBasedPrice(useMarketBasedPrice)
.setOwnerNodeAddress(ownerNodeAddress.toProtoMessage())
.setPubKeyRing(pubKeyRing.toProtoMessage())
.setDirection(Direction.toProtoMessage(direction))
.setPrice(price)
.setMarketPriceMargin(marketPriceMargin)
.setUseMarketBasedPrice(useMarketBasedPrice)
.setAmount(amount)
.setMinAmount(minAmount)
.setMakerNodeAddress(makerNodeAddress.toProtoMessage())
.setPubKeyRing(pubKeyRing.toProtoMessage())
.setBaseCurrencyCode(baseCurrencyCode)
.setCounterCurrencyCode(counterCurrencyCode)
.addAllArbitratorNodeAddresses(arbitratorNodeAddresses.stream()
.map(NodeAddress::toProtoMessage)
.collect(Collectors.toList()))
.addAllMediatorNodeAddresses(mediatorNodeAddresses.stream()
.map(NodeAddress::toProtoMessage)
.collect(Collectors.toList()))
.setPaymentMethodId(paymentMethodId)
.setMakerPaymentAccountId(makerPaymentAccountId)
.setVersionNr(versionNr)
.setBlockHeightAtOfferCreation(blockHeightAtOfferCreation)
@ -297,49 +262,39 @@ public final class OfferPayload implements StoragePayload, RequiresOwnerIsOnline
.setUseReOpenAfterAutoClose(useReOpenAfterAutoClose)
.setLowerClosePrice(lowerClosePrice)
.setUpperClosePrice(upperClosePrice)
.setIsPrivateOffer(isPrivateOffer);
.setIsPrivateOffer(isPrivateOffer)
.setProtocolVersion(protocolVersion);
if (Objects.nonNull(offerFeePaymentTxId)) {
offerBuilder.setOfferFeePaymentTxId(offerFeePaymentTxId);
builder.setOfferFeePaymentTxId(offerFeePaymentTxId);
} else {
throw new RuntimeException("OfferPayload is in invalid state: offerFeePaymentTxID is not set when adding to P2P network.");
}
Optional.ofNullable(countryCode).ifPresent(offerBuilder::setCountryCode);
Optional.ofNullable(bankId).ifPresent(offerBuilder::setBankId);
Optional.ofNullable(acceptedBankIds).ifPresent(offerBuilder::addAllAcceptedBankIds);
Optional.ofNullable(hashOfChallenge).ifPresent(offerBuilder::setHashOfChallenge);
Optional.ofNullable(acceptedCountryCodes).ifPresent(offerBuilder::addAllAcceptedCountryCodes);
Optional.ofNullable(extraDataMap).ifPresent(offerBuilder::putAllExtraDataMap);
Optional.ofNullable(countryCode).ifPresent(builder::setCountryCode);
Optional.ofNullable(bankId).ifPresent(builder::setBankId);
Optional.ofNullable(acceptedBankIds).ifPresent(builder::addAllAcceptedBankIds);
Optional.ofNullable(acceptedCountryCodes).ifPresent(builder::addAllAcceptedCountryCodes);
Optional.ofNullable(hashOfChallenge).ifPresent(builder::setHashOfChallenge);
Optional.ofNullable(extraDataMap).ifPresent(builder::putAllExtraData);
return PB.StoragePayload.newBuilder().setOfferPayload(offerBuilder).build();
return PB.StoragePayload.newBuilder().setOfferPayload(builder).build();
}
public static OfferPayload fromProto(PB.OfferPayload proto) {
List<NodeAddress> arbitratorNodeAddresses = proto.getArbitratorNodeAddressesList().stream()
.map(NodeAddress::fromProto).collect(Collectors.toList());
List<NodeAddress> mediatorNodeAddresses = proto.getMediatorNodeAddressesList().stream()
.map(NodeAddress::fromProto).collect(Collectors.toList());
// Nullable object need to be checked against the default values in PB (not nice... ;-( )
// convert these lists because otherwise when they're empty they are lazyStringArrayList objects and NOT serializable,
// which is needed for the P2PStorage getHash() operation
List<String> acceptedCountryCodes = proto.getAcceptedCountryCodesList().isEmpty() ?
null : proto.getAcceptedCountryCodesList().stream().collect(Collectors.toList());
checkArgument(proto.getOfferFeePaymentTxId().isEmpty(), "OfferFeePaymentTxId must be set in PB.OfferPayload");
String countryCode = proto.getCountryCode().isEmpty() ? null : proto.getCountryCode();
String bankId = proto.getBankId().isEmpty() ? null : proto.getBankId();
List<String> acceptedBankIds = proto.getAcceptedBankIdsList().isEmpty() ?
null : proto.getAcceptedBankIdsList().stream().collect(Collectors.toList());
Map<String, String> extraDataMapMap = CollectionUtils.isEmpty(proto.getExtraDataMapMap()) ?
null : proto.getExtraDataMapMap();
final String countryCode1 = proto.getCountryCode();
String countryCode = countryCode1.isEmpty() ? null : countryCode1;
String bankId = proto.getBankId().isEmpty() ? null : proto.getBankId();
String offerFeePaymentTxId = proto.getOfferFeePaymentTxId().isEmpty() ? null : proto.getOfferFeePaymentTxId();
List<String> acceptedCountryCodes = proto.getAcceptedCountryCodesList().isEmpty() ?
null : proto.getAcceptedCountryCodesList().stream().collect(Collectors.toList());
String hashOfChallenge = proto.getHashOfChallenge().isEmpty() ? null : proto.getHashOfChallenge();
Map<String, String> extraDataMapMap = CollectionUtils.isEmpty(proto.getExtraDataMap()) ?
null : proto.getExtraDataMap();
return new OfferPayload(proto.getId(),
proto.getDate(),
NodeAddress.fromProto(proto.getMakerNodeAddress()),
NodeAddress.fromProto(proto.getOwnerNodeAddress()),
PubKeyRing.fromProto(proto.getPubKeyRing()),
OfferPayload.Direction.fromProto(proto.getDirection()),
proto.getPrice(),
@ -349,11 +304,15 @@ public final class OfferPayload implements StoragePayload, RequiresOwnerIsOnline
proto.getMinAmount(),
proto.getBaseCurrencyCode(),
proto.getCounterCurrencyCode(),
arbitratorNodeAddresses,
mediatorNodeAddresses,
proto.getArbitratorNodeAddressesList().stream()
.map(NodeAddress::fromProto)
.collect(Collectors.toList()),
proto.getMediatorNodeAddressesList().stream()
.map(NodeAddress::fromProto)
.collect(Collectors.toList()),
proto.getPaymentMethodId(),
proto.getMakerPaymentAccountId(),
offerFeePaymentTxId,
proto.getOfferFeePaymentTxId(),
countryCode,
acceptedCountryCodes,
bankId,
@ -375,4 +334,27 @@ public final class OfferPayload implements StoragePayload, RequiresOwnerIsOnline
hashOfChallenge,
extraDataMapMap);
}
///////////////////////////////////////////////////////////////////////////////////////////
// API
///////////////////////////////////////////////////////////////////////////////////////////
@Override
public PublicKey getOwnerPubKey() {
return pubKeyRing.getSignaturePubKey();
}
// In the offer we support base and counter currency
// Fiat offers have base currency BTC and counterCurrency Fiat
// Altcoins have base currency Altcoin and counterCurrency BTC
// The rest of the app does not support yet that concept of base currency and counter currencies
// so we map here for convenience
public String getCurrencyCode() {
if (CurrencyUtil.isCryptoCurrency(getBaseCurrencyCode()))
return getBaseCurrencyCode();
else
return getCounterCurrencyCode();
}
}

3
core/src/main/java/io/bisq/core/offer/OpenOffer.java
View file

@ -62,11 +62,10 @@ public final class OpenOffer implements Tradable {
@Override
public Message toProtoMessage() {
final PB.OpenOffer build = PB.OpenOffer.newBuilder()
return PB.OpenOffer.newBuilder()
.setOffer(offer.toProtoMessage())
.setState(PB.OpenOffer.State.valueOf(state.name()))
.build();
return build;
}
public static Tradable fromProto(PB.OpenOffer proto, Storage<TradableList<OpenOffer>> storage) {

2
core/src/main/java/io/bisq/core/offer/messages/OfferAvailabilityRequest.java
View file

@ -22,12 +22,14 @@ import io.bisq.common.crypto.PubKeyRing;
import io.bisq.common.proto.network.NetworkEnvelope;
import io.bisq.generated.protobuffer.PB;
import io.bisq.network.p2p.SupportedCapabilitiesMessage;
import lombok.EqualsAndHashCode;
import lombok.Value;
import java.util.ArrayList;
// We add here the SupportedCapabilitiesMessage interface as that message always predates a direct connection
// to the trading peer
@EqualsAndHashCode(callSuper = true)
@Value
public final class OfferAvailabilityRequest extends OfferMessage implements SupportedCapabilitiesMessage {
private final PubKeyRing pubKeyRing;

2
core/src/main/java/io/bisq/core/offer/messages/OfferAvailabilityResponse.java
View file

@ -23,12 +23,14 @@ import io.bisq.common.proto.network.NetworkEnvelope;
import io.bisq.core.offer.AvailabilityResult;
import io.bisq.generated.protobuffer.PB;
import io.bisq.network.p2p.SupportedCapabilitiesMessage;
import lombok.EqualsAndHashCode;
import lombok.Value;
import java.util.ArrayList;
// We add here the SupportedCapabilitiesMessage interface as that message always predates a direct connection
// to the trading peer
@EqualsAndHashCode(callSuper = true)
@Value
public final class OfferAvailabilityResponse extends OfferMessage implements SupportedCapabilitiesMessage {
private final AvailabilityResult availabilityResult;

76
core/src/main/java/io/bisq/core/payment/PaymentAccount.java
View file

@ -35,26 +35,23 @@ import java.util.stream.Collectors;
@EqualsAndHashCode
@ToString
@Getter
@Slf4j
public abstract class PaymentAccount implements PersistablePayload {
@Getter
protected final String id;
protected final long creationDate;
@Getter
protected final PaymentMethod paymentMethod;
@Getter
@Setter
protected String accountName;
@Getter
final List<TradeCurrency> tradeCurrencies = new ArrayList<>();
@Getter
@Setter
protected TradeCurrency selectedTradeCurrency;
@Getter
protected final String id;
protected final long creationDate;
@Setter
public PaymentAccountPayload paymentAccountPayload;
@Setter
protected String accountName;
protected final List<TradeCurrency> tradeCurrencies = new ArrayList<>();
@Setter
protected TradeCurrency selectedTradeCurrency;
///////////////////////////////////////////////////////////////////////////////////////////
// Constructor
///////////////////////////////////////////////////////////////////////////////////////////
@ -67,6 +64,33 @@ public abstract class PaymentAccount implements PersistablePayload {
}
///////////////////////////////////////////////////////////////////////////////////////////
// PROTO BUFFER
///////////////////////////////////////////////////////////////////////////////////////////
@Override
public PB.PaymentAccount toProtoMessage() {
PB.PaymentAccount.Builder builder = PB.PaymentAccount.newBuilder()
.setPaymentMethod(paymentMethod.toProtoMessage())
.setId(paymentMethod.getId())
.setCreationDate(creationDate)
.setPaymentAccountPayload((PB.PaymentAccountPayload) paymentAccountPayload.toProtoMessage())
.setAccountName(accountName)
.addAllTradeCurrencies(ProtoCollectionUtil.<PB.TradeCurrency>collectionToProto(tradeCurrencies));
Optional.ofNullable(selectedTradeCurrency).ifPresent(selectedTradeCurrency -> builder.setSelectedTradeCurrency((PB.TradeCurrency) selectedTradeCurrency.toProtoMessage()));
return builder.build();
}
public static PaymentAccount fromProto(PB.PaymentAccount proto) {
PaymentAccount paymentAccount = PaymentAccountFactory.getPaymentAccount(PaymentMethod.getPaymentMethodById(proto.getPaymentMethod().getId()));
paymentAccount.setAccountName(proto.getAccountName());
paymentAccount.getTradeCurrencies().addAll(proto.getTradeCurrenciesList().stream().map(TradeCurrency::fromProto).collect(Collectors.toList()));
paymentAccount.setSelectedTradeCurrency(paymentAccount.getSelectedTradeCurrency());
paymentAccount.setPaymentAccountPayload(PaymentAccountPayload.fromProto(proto.getPaymentAccountPayload()));
return paymentAccount;
}
///////////////////////////////////////////////////////////////////////////////////////////
// API
///////////////////////////////////////////////////////////////////////////////////////////
@ -109,28 +133,4 @@ public abstract class PaymentAccount implements PersistablePayload {
///////////////////////////////////////////////////////////////////////////////////////////
protected abstract PaymentAccountPayload getPayload();
@Override
public PB.PaymentAccount toProtoMessage() {
PB.PaymentAccount.Builder builder = PB.PaymentAccount.newBuilder()
.setId(paymentMethod.getId())
.setCreationDate(creationDate)
.setPaymentMethod(paymentMethod.toProtoMessage())
.setAccountName(accountName)
.addAllTradeCurrencies(ProtoCollectionUtil.collectionToProto(tradeCurrencies))
.setPaymentAccountPayload((PB.PaymentAccountPayload) paymentAccountPayload.toProtoMessage());
Optional.ofNullable(selectedTradeCurrency).ifPresent(selectedTradeCurrency -> builder.setSelectedTradeCurrency((PB.TradeCurrency) selectedTradeCurrency.toProtoMessage()));
return builder.build();
}
// complicated: uses a factory to get the specific type, which then calls the ctor which does getPayload for id etc
public static PaymentAccount fromProto(PB.PaymentAccount account) {
PaymentAccount paymentAccount = PaymentAccountFactory.getPaymentAccount(PaymentMethod.getPaymentMethodById(account.getPaymentMethod().getId()));
paymentAccount.setAccountName(account.getAccountName());
paymentAccount.getTradeCurrencies().addAll(account.getTradeCurrenciesList().stream().map(tradeCurrency -> TradeCurrency.fromProto(tradeCurrency)).collect(Collectors.toList()));
paymentAccount.setSelectedTradeCurrency(paymentAccount.getSelectedTradeCurrency());
paymentAccount.setPaymentAccountPayload(PaymentAccountPayload.fromProto(account.getPaymentAccountPayload()));
return paymentAccount;
}
}

98
core/src/main/java/io/bisq/core/payment/payload/PaymentAccountPayload.java
View file

@ -19,7 +19,7 @@ package io.bisq.core.payment.payload;
import io.bisq.common.locale.CountryUtil;
import io.bisq.common.proto.network.NetworkPayload;
import io.bisq.core.proto.ProtoUtil;
import io.bisq.core.proto.ProtoCoreUtil;
import io.bisq.generated.protobuffer.PB;
import lombok.EqualsAndHashCode;
import lombok.Getter;
@ -56,101 +56,101 @@ public abstract class PaymentAccountPayload implements NetworkPayload {
abstract public String getPaymentDetailsForTradePopup();
public static PaymentAccountPayload fromProto(PB.PaymentAccountPayload protoEntry) {
public static PaymentAccountPayload fromProto(PB.PaymentAccountPayload proto) {
PaymentAccountPayload result = null;
switch (protoEntry.getMessageCase()) {
switch (proto.getMessageCase()) {
case ALI_PAY_ACCOUNT_PAYLOAD:
result = new AliPayAccountPayload(protoEntry.getPaymentMethodId(), protoEntry.getId(),
protoEntry.getMaxTradePeriod(), protoEntry.getAliPayAccountPayload().getAccountNr());
result = new AliPayAccountPayload(proto.getPaymentMethodId(), proto.getId(),
proto.getMaxTradePeriod(), proto.getAliPayAccountPayload().getAccountNr());
break;
case CHASE_QUICK_PAY_ACCOUNT_PAYLOAD:
result = new ChaseQuickPayAccountPayload(protoEntry.getPaymentMethodId(), protoEntry.getId(),
protoEntry.getMaxTradePeriod(), protoEntry.getChaseQuickPayAccountPayload().getEmail(),
protoEntry.getChaseQuickPayAccountPayload().getHolderName());
result = new ChaseQuickPayAccountPayload(proto.getPaymentMethodId(), proto.getId(),
proto.getMaxTradePeriod(), proto.getChaseQuickPayAccountPayload().getEmail(),
proto.getChaseQuickPayAccountPayload().getHolderName());
break;
case CLEAR_XCHANGE_ACCOUNT_PAYLOAD:
result = new ClearXchangeAccountPayload(protoEntry.getPaymentMethodId(), protoEntry.getId(),
protoEntry.getMaxTradePeriod(), protoEntry.getClearXchangeAccountPayload().getHolderName(),
protoEntry.getClearXchangeAccountPayloadOrBuilder().getEmailOrMobileNr());
result = new ClearXchangeAccountPayload(proto.getPaymentMethodId(), proto.getId(),
proto.getMaxTradePeriod(), proto.getClearXchangeAccountPayload().getHolderName(),
proto.getClearXchangeAccountPayloadOrBuilder().getEmailOrMobileNr());
break;
case COUNTRY_BASED_PAYMENT_ACCOUNT_PAYLOAD:
switch (protoEntry.getCountryBasedPaymentAccountPayload().getMessageCase()) {
switch (proto.getCountryBasedPaymentAccountPayload().getMessageCase()) {
case BANK_ACCOUNT_PAYLOAD:
switch (protoEntry.getCountryBasedPaymentAccountPayload().getBankAccountPayload().getMessageCase()) {
switch (proto.getCountryBasedPaymentAccountPayload().getBankAccountPayload().getMessageCase()) {
case NATIONAL_BANK_ACCOUNT_PAYLOAD:
NationalBankAccountPayload nationalBankAccountPayload = new NationalBankAccountPayload(protoEntry.getPaymentMethodId(), protoEntry.getId(),
protoEntry.getMaxTradePeriod());
ProtoUtil.fillInBankAccountPayload(protoEntry, nationalBankAccountPayload);
ProtoUtil.fillInCountryBasedPaymentAccountPayload(protoEntry, nationalBankAccountPayload);
NationalBankAccountPayload nationalBankAccountPayload = new NationalBankAccountPayload(proto.getPaymentMethodId(), proto.getId(),
proto.getMaxTradePeriod());
ProtoCoreUtil.fillInBankAccountPayload(proto, nationalBankAccountPayload);
ProtoCoreUtil.fillInCountryBasedPaymentAccountPayload(proto, nationalBankAccountPayload);
result = nationalBankAccountPayload;
break;
case SAME_BANK_ACCONT_PAYLOAD:
SameBankAccountPayload sameBankAccountPayload = new SameBankAccountPayload(protoEntry.getPaymentMethodId(), protoEntry.getId(),
protoEntry.getMaxTradePeriod());
ProtoUtil.fillInBankAccountPayload(protoEntry, sameBankAccountPayload);
ProtoUtil.fillInCountryBasedPaymentAccountPayload(protoEntry, sameBankAccountPayload);
SameBankAccountPayload sameBankAccountPayload = new SameBankAccountPayload(proto.getPaymentMethodId(), proto.getId(),
proto.getMaxTradePeriod());
ProtoCoreUtil.fillInBankAccountPayload(proto, sameBankAccountPayload);
ProtoCoreUtil.fillInCountryBasedPaymentAccountPayload(proto, sameBankAccountPayload);
result = sameBankAccountPayload;
break;
case SPECIFIC_BANKS_ACCOUNT_PAYLOAD:
SpecificBanksAccountPayload specificBanksAccountPayload = new SpecificBanksAccountPayload(protoEntry.getPaymentMethodId(), protoEntry.getId(),
protoEntry.getMaxTradePeriod());
ProtoUtil.fillInBankAccountPayload(protoEntry, specificBanksAccountPayload);
ProtoUtil.fillInCountryBasedPaymentAccountPayload(protoEntry, specificBanksAccountPayload);
SpecificBanksAccountPayload specificBanksAccountPayload = new SpecificBanksAccountPayload(proto.getPaymentMethodId(), proto.getId(),
proto.getMaxTradePeriod());
ProtoCoreUtil.fillInBankAccountPayload(proto, specificBanksAccountPayload);
ProtoCoreUtil.fillInCountryBasedPaymentAccountPayload(proto, specificBanksAccountPayload);
result = specificBanksAccountPayload;
break;
}
break;
case CASH_DEPOSIT_ACCOUNT_PAYLOAD:
CashDepositAccountPayload cashDepositAccountPayload = new CashDepositAccountPayload(protoEntry.getPaymentMethodId(), protoEntry.getId(),
protoEntry.getMaxTradePeriod());
ProtoUtil.fillInCountryBasedPaymentAccountPayload(protoEntry, cashDepositAccountPayload);
CashDepositAccountPayload cashDepositAccountPayload = new CashDepositAccountPayload(proto.getPaymentMethodId(), proto.getId(),
proto.getMaxTradePeriod());
ProtoCoreUtil.fillInCountryBasedPaymentAccountPayload(proto, cashDepositAccountPayload);
result = cashDepositAccountPayload;
break;
case SEPA_ACCOUNT_PAYLOAD:
SepaAccountPayload sepaAccountPayload = new SepaAccountPayload(protoEntry.getPaymentMethodId(), protoEntry.getId(),
protoEntry.getMaxTradePeriod(), CountryUtil.getAllSepaCountries());
ProtoUtil.fillInCountryBasedPaymentAccountPayload(protoEntry, sepaAccountPayload);
SepaAccountPayload sepaAccountPayload = new SepaAccountPayload(proto.getPaymentMethodId(), proto.getId(),
proto.getMaxTradePeriod(), CountryUtil.getAllSepaCountries());
ProtoCoreUtil.fillInCountryBasedPaymentAccountPayload(proto, sepaAccountPayload);
result = sepaAccountPayload;
break;
}
break;
case CRYPTO_CURRENCY_ACCOUNT_PAYLOAD:
result = new CryptoCurrencyAccountPayload(protoEntry.getPaymentMethodId(), protoEntry.getId(),
protoEntry.getMaxTradePeriod(), protoEntry.getCryptoCurrencyAccountPayload().getAddress());
result = new CryptoCurrencyAccountPayload(proto.getPaymentMethodId(), proto.getId(),
proto.getMaxTradePeriod(), proto.getCryptoCurrencyAccountPayload().getAddress());
break;
case FASTER_PAYMENTS_ACCOUNT_PAYLOAD:
result = new FasterPaymentsAccountPayload(protoEntry.getPaymentMethodId(), protoEntry.getId(),
protoEntry.getMaxTradePeriod(), protoEntry.getFasterPaymentsAccountPayload().getSortCode(),
protoEntry.getFasterPaymentsAccountPayload().getAccountNr());
result = new FasterPaymentsAccountPayload(proto.getPaymentMethodId(), proto.getId(),
proto.getMaxTradePeriod(), proto.getFasterPaymentsAccountPayload().getSortCode(),
proto.getFasterPaymentsAccountPayload().getAccountNr());
break;
case INTERAC_E_TRANSFER_ACCOUNT_PAYLOAD:
PB.InteracETransferAccountPayload interacETransferAccountPayload =
protoEntry.getInteracETransferAccountPayload();
result = new InteracETransferAccountPayload(protoEntry.getPaymentMethodId(), protoEntry.getId(),
protoEntry.getMaxTradePeriod(), interacETransferAccountPayload.getEmail(),
proto.getInteracETransferAccountPayload();
result = new InteracETransferAccountPayload(proto.getPaymentMethodId(), proto.getId(),
proto.getMaxTradePeriod(), interacETransferAccountPayload.getEmail(),
interacETransferAccountPayload.getHolderName(),
interacETransferAccountPayload.getQuestion(),
interacETransferAccountPayload.getAnswer());
break;
case O_K_PAY_ACCOUNT_PAYLOAD:
result = getOkPayAccountPayload(protoEntry);
result = getOkPayAccountPayload(proto);
break;
case PERFECT_MONEY_ACCOUNT_PAYLOAD:
result = new PerfectMoneyAccountPayload(protoEntry.getPaymentMethodId(), protoEntry.getId(),
protoEntry.getMaxTradePeriod(), protoEntry.getPerfectMoneyAccountPayload().getAccountNr());
result = new PerfectMoneyAccountPayload(proto.getPaymentMethodId(), proto.getId(),
proto.getMaxTradePeriod(), proto.getPerfectMoneyAccountPayload().getAccountNr());
break;
case SWISH_ACCOUNT_PAYLOAD:
result = new SwishAccountPayload(protoEntry.getPaymentMethodId(), protoEntry.getId(),
protoEntry.getMaxTradePeriod(), protoEntry.getSwishAccountPayload().getMobileNr(),
protoEntry.getSwishAccountPayload().getHolderName());
result = new SwishAccountPayload(proto.getPaymentMethodId(), proto.getId(),
proto.getMaxTradePeriod(), proto.getSwishAccountPayload().getMobileNr(),
proto.getSwishAccountPayload().getHolderName());
break;
case U_S_POSTAL_MONEY_ORDER_ACCOUNT_PAYLOAD:
result = new USPostalMoneyOrderAccountPayload(protoEntry.getPaymentMethodId(), protoEntry.getId(),
protoEntry.getMaxTradePeriod(), protoEntry.getUSPostalMoneyOrderAccountPayload().getPostalAddress(),
protoEntry.getUSPostalMoneyOrderAccountPayload().getHolderName());
result = new USPostalMoneyOrderAccountPayload(proto.getPaymentMethodId(), proto.getId(),
proto.getMaxTradePeriod(), proto.getUSPostalMoneyOrderAccountPayload().getPostalAddress(),
proto.getUSPostalMoneyOrderAccountPayload().getHolderName());
break;
default:
log.error("Unknown paymentaccountcontractdata:{}", protoEntry.getMessageCase());
log.error("Unknown paymentaccountcontractdata:{}", proto.getMessageCase());
}
return result;
}

70
core/src/main/java/io/bisq/core/payment/payload/PaymentMethod.java
View file

@ -27,7 +27,6 @@ import lombok.extern.slf4j.Slf4j;
import org.bitcoinj.core.Coin;
import org.jetbrains.annotations.NotNull;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
@ -35,11 +34,16 @@ import java.util.Optional;
// Don't use Enum as it breaks serialisation when changing entries and we want to stay flexible here
@EqualsAndHashCode
@EqualsAndHashCode(exclude = {"maxTradePeriod", "maxTradeLimit"})
@Getter
@ToString
@Slf4j
public final class PaymentMethod implements PersistablePayload, Comparable {
///////////////////////////////////////////////////////////////////////////////////////////
// Static
///////////////////////////////////////////////////////////////////////////////////////////
// time in blocks (average 10 min for one block confirmation
private static final long HOUR = 3600_000;
private static final long DAY = HOUR * 24;
@ -111,10 +115,20 @@ public final class PaymentMethod implements PersistablePayload, Comparable {
BLOCK_CHAINS = new PaymentMethod(BLOCK_CHAINS_ID, DAY, Coin.parseCoin("1"))
));
///////////////////////////////////////////////////////////////////////////////////////////
// Instance fields
///////////////////////////////////////////////////////////////////////////////////////////
private final String id;
private long maxTradePeriod;
private long maxTradeLimit;
///////////////////////////////////////////////////////////////////////////////////////////
// Constructor
///////////////////////////////////////////////////////////////////////////////////////////
/**
* @param id against charge back risk. If Bank do the charge back quickly the Arbitrator and the seller can push another
* double spend tx to invalidate the time locked payout tx. For the moment we set all to 0 but will have it in
@ -128,30 +142,41 @@ public final class PaymentMethod implements PersistablePayload, Comparable {
this.maxTradeLimit = maxTradeLimit.value;
}
///////////////////////////////////////////////////////////////////////////////////////////
// PROTO BUFFER
///////////////////////////////////////////////////////////////////////////////////////////
@Override
public PB.PaymentMethod toProtoMessage() {
return PB.PaymentMethod.newBuilder()
.setId(id)
.setMaxTradePeriod(maxTradePeriod)
.setMaxTradeLimit(maxTradeLimit).build();
}
public static PaymentMethod fromProto(PB.PaymentMethod proto) {
return new PaymentMethod(proto.getId(),
proto.getMaxTradePeriod(),
Coin.valueOf(proto.getMaxTradeLimit()));
}
///////////////////////////////////////////////////////////////////////////////////////////
// API
///////////////////////////////////////////////////////////////////////////////////////////
// Used for dummy entries in payment methods list (SHOW_ALL)
public PaymentMethod(String id) {
this(id, 0, Coin.ZERO);
}
private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
try {
in.defaultReadObject();
// In case we update those values we want that the persisted accounts get updated as well
PaymentMethod paymentMethod = PaymentMethod.getPaymentMethodById(id);
this.maxTradePeriod = paymentMethod.getMaxTradePeriod();
this.maxTradeLimit = paymentMethod.getMaxTradeLimit();
} catch (Throwable t) {
log.warn("Cannot be deserialized." + t.getMessage());
}
}
public static PaymentMethod getPaymentMethodById(String id) {
Optional<PaymentMethod> paymentMethodOptional = ALL_VALUES.stream().filter(e -> e.getId().equals(id)).findFirst();
if (paymentMethodOptional.isPresent())
return paymentMethodOptional.get();
else
return new PaymentMethod(Res.get("shared.na"), DAY, Coin.parseCoin("0"));
return new PaymentMethod(Res.get("shared.na"));
}
public Coin getMaxTradeLimitAsCoin() {
@ -165,17 +190,4 @@ public final class PaymentMethod implements PersistablePayload, Comparable {
else
return 0;
}
@Override
public PB.PaymentMethod toProtoMessage() {
return PB.PaymentMethod.newBuilder()
.setId(id)
.setMaxTradePeriod(maxTradePeriod)
.setMaxTradeLimit(maxTradeLimit).build();
}
public static PaymentMethod fromProto(PB.PaymentMethod paymentMethod) {
return new PaymentMethod(paymentMethod.getId(), paymentMethod.getMaxTradePeriod(),
Coin.valueOf(paymentMethod.getMaxTradeLimit()));
}
}

7
core/src/main/java/io/bisq/core/proto/ProtoUtil.java → core/src/main/java/io/bisq/core/proto/ProtoCoreUtil.java
View file

@ -18,17 +18,12 @@
package io.bisq.core.proto;
import io.bisq.common.locale.CurrencyUtil;
import io.bisq.core.filter.PaymentAccountFilter;
import io.bisq.core.payment.payload.BankAccountPayload;
import io.bisq.core.payment.payload.CountryBasedPaymentAccountPayload;
import io.bisq.generated.protobuffer.PB;
public class ProtoUtil {
public class ProtoCoreUtil {
public static PaymentAccountFilter getPaymentAccountFilter(PB.PaymentAccountFilter accountFilter) {
return new PaymentAccountFilter(accountFilter.getPaymentMethodId(), accountFilter.getGetMethodName(),
accountFilter.getValue());
}
public static String getCurrencyCode(PB.OfferPayload pbOffer) {
return CurrencyUtil.isCryptoCurrency(pbOffer.getBaseCurrencyCode()) ? pbOffer.getBaseCurrencyCode() : pbOffer.getCounterCurrencyCode();

2
core/src/main/java/io/bisq/core/proto/network/CoreNetworkProtoResolver.java
View file

@ -150,7 +150,7 @@ public class CoreNetworkProtoResolver implements NetworkProtoResolver {
case TRADE_STATISTICS:
return TradeStatistics.fromProto(proto.getTradeStatistics());
case MAILBOX_STORAGE_PAYLOAD:
return MailboxStoragePayload.fromProto(proto.getMailboxStoragePayload(), this);
return MailboxStoragePayload.fromProto(proto.getMailboxStoragePayload());
case OFFER_PAYLOAD:
return OfferPayload.fromProto(proto.getOfferPayload());
default:

8
core/src/main/java/io/bisq/core/trade/protocol/ProcessModel.java
View file

@ -176,16 +176,16 @@ public class ProcessModel implements Model, PersistablePayload {
public boolean isPeersPaymentAccountDataAreBanned(PaymentAccountPayload paymentAccountPayload,
PaymentAccountFilter[] appliedPaymentAccountFilter) {
return filterManager.getFilter() != null &&
filterManager.getFilter().bannedPaymentAccounts.stream()
filterManager.getFilter().getBannedPaymentAccounts().stream()
.filter(paymentAccountFilter -> {
final boolean samePaymentMethodId = paymentAccountFilter.paymentMethodId.equals(
final boolean samePaymentMethodId = paymentAccountFilter.getPaymentMethodId().equals(
paymentAccountPayload.getPaymentMethodId());
if (samePaymentMethodId) {
try {
Method method = paymentAccountPayload.getClass().getMethod(paymentAccountFilter.getMethodName);
Method method = paymentAccountPayload.getClass().getMethod(paymentAccountFilter.getGetMethodName());
String result = (String) method.invoke(paymentAccountPayload);
appliedPaymentAccountFilter[0] = paymentAccountFilter;
return result.equals(paymentAccountFilter.value);
return result.equals(paymentAccountFilter.getValue());
} catch (Throwable e) {
log.error(e.getMessage());
return false;

167
core/src/main/java/io/bisq/core/trade/statistics/TradeStatistics.java
View file

@ -11,8 +11,8 @@ import io.bisq.core.offer.OfferPayload;
import io.bisq.generated.protobuffer.PB;
import io.bisq.network.p2p.storage.payload.LazyProcessedStoragePayload;
import io.bisq.network.p2p.storage.payload.PersistedStoragePayload;
import lombok.Getter;
import lombok.ToString;
import lombok.EqualsAndHashCode;
import lombok.Value;
import lombok.extern.slf4j.Slf4j;
import org.bitcoinj.core.Coin;
import org.bitcoinj.utils.ExchangeRate;
@ -20,46 +20,44 @@ import org.bitcoinj.utils.Fiat;
import org.springframework.util.CollectionUtils;
import javax.annotation.Nullable;
import javax.annotation.concurrent.Immutable;
import java.security.PublicKey;
import java.util.Date;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
@ToString
@Slf4j
@Immutable
public final class TradeStatistics implements LazyProcessedStoragePayload, /*CapabilityRequiringPayload,*/ PersistedStoragePayload {
@JsonExclude
public static final long TTL = TimeUnit.DAYS.toMillis(30);
// We don't include the pubKeyRing as both traders might publish it if the maker uses an old
// version and update later (taker publishes first, then later maker)
// We also don't include the trade date as that is set locally and different for maker and taker
// Payload
public final String baseCurrency;
public final String counterCurrency;
public final OfferPayload.Direction direction;
public final long tradePrice;
public final long tradeAmount;
public final long tradeDate;
public final String paymentMethodId;
public final long offerDate;
public final boolean useMarketBasedPrice;
public final double marketPriceMargin;
public final long offerAmount;
public final long offerMinAmount;
@Getter
public final String offerId;
public final String depositTxId;
@Slf4j
@EqualsAndHashCode(exclude = {"pubKeyRing"})
@Value
public final class TradeStatistics implements LazyProcessedStoragePayload, PersistedStoragePayload /*,CapabilityRequiringPayload*/ {
@JsonExclude
public final PubKeyRing pubKeyRing;
private final long TTL = TimeUnit.DAYS.toMillis(30);
private final OfferPayload.Direction direction;
private final String baseCurrency;
private final String counterCurrency;
private final String offerPaymentMethod;
private final long offerDate;
private final boolean offerUseMarketBasedPrice;
private final double offerMarketPriceMargin;
private final long offerAmount;
private final long offerMinAmount;
private final String offerId;
private final long tradePrice;
private final long tradeAmount;
private final long tradeDate;
private final String depositTxId;
@JsonExclude
private final PubKeyRing pubKeyRing;
// Should be only used in emergency case if we need to add data but do not want to break backward compatibility
// at the P2P network storage checks. The hash of the object will be used to verify if the data is valid. Any new
// field in a class would break that hash and therefore break the storage mechanism.
@Getter
@Nullable
private Map<String, String> extraDataMap;
// Called from domain
public TradeStatistics(OfferPayload offerPayload,
Price tradePrice,
Coin tradeAmount,
@ -108,10 +106,10 @@ public final class TradeStatistics implements LazyProcessedStoragePayload, /*Cap
this.direction = direction;
this.baseCurrency = baseCurrency;
this.counterCurrency = counterCurrency;
this.paymentMethodId = offerPaymentMethod;
this.offerPaymentMethod = offerPaymentMethod;
this.offerDate = offerDate;
this.useMarketBasedPrice = offerUseMarketBasedPrice;
this.marketPriceMargin = offerMarketPriceMargin;
this.offerUseMarketBasedPrice = offerUseMarketBasedPrice;
this.offerMarketPriceMargin = offerMarketPriceMargin;
this.offerAmount = offerAmount;
this.offerMinAmount = offerMinAmount;
this.offerId = offerId;
@ -126,44 +124,43 @@ public final class TradeStatistics implements LazyProcessedStoragePayload, /*Cap
@Override
public PB.StoragePayload toProtoMessage() {
final PB.TradeStatistics.Builder builder = PB.TradeStatistics.newBuilder()
.setDirection(OfferPayload.Direction.toProtoMessage(direction))
.setBaseCurrency(baseCurrency)
.setCounterCurrency(counterCurrency)
.setDirection(PB.OfferPayload.Direction.valueOf(direction.name()))
.setTradePrice(tradePrice)
.setTradeAmount(tradeAmount)
.setTradeDate(tradeDate)
.setPaymentMethodId(paymentMethodId)
.setPaymentMethodId(offerPaymentMethod)
.setOfferDate(offerDate)
.setUseMarketBasedPrice(useMarketBasedPrice)
.setMarketPriceMargin(marketPriceMargin)
.setOfferUseMarketBasedPrice(offerUseMarketBasedPrice)
.setOfferMarketPriceMargin(offerMarketPriceMargin)
.setOfferAmount(offerAmount)
.setOfferMinAmount(offerMinAmount)
.setOfferId(offerId)
.setTradePrice(tradePrice)
.setTradeAmount(tradeAmount)
.setTradeDate(tradeDate)
.setDepositTxId(depositTxId)
.setPubKeyRing(pubKeyRing.toProtoMessage());
Optional.ofNullable(extraDataMap).ifPresent(builder::putAllExtraDataMap);
Optional.ofNullable(extraDataMap).ifPresent(builder::putAllExtraData);
return PB.StoragePayload.newBuilder().setTradeStatistics(builder).build();
}
public static TradeStatistics fromProto(PB.TradeStatistics tradeStatistics) {
public static TradeStatistics fromProto(PB.TradeStatistics proto) {
return new TradeStatistics(
OfferPayload.Direction.fromProto(tradeStatistics.getDirection()),
tradeStatistics.getBaseCurrency(),
tradeStatistics.getCounterCurrency(),
tradeStatistics.getPaymentMethodId(),
tradeStatistics.getOfferDate(),
tradeStatistics.getUseMarketBasedPrice(),
tradeStatistics.getMarketPriceMargin(),
tradeStatistics.getOfferAmount(),
tradeStatistics.getOfferMinAmount(),
tradeStatistics.getOfferId(),
tradeStatistics.getTradePrice(),
tradeStatistics.getTradeAmount(),
tradeStatistics.getTradeDate(),
tradeStatistics.getDepositTxId(),
PubKeyRing.fromProto(tradeStatistics.getPubKeyRing()),
CollectionUtils.isEmpty(tradeStatistics.getExtraDataMapMap()) ?
null : tradeStatistics.getExtraDataMapMap());
OfferPayload.Direction.fromProto(proto.getDirection()),
proto.getBaseCurrency(),
proto.getCounterCurrency(),
proto.getPaymentMethodId(),
proto.getOfferDate(),
proto.getOfferUseMarketBasedPrice(),
proto.getOfferMarketPriceMargin(),
proto.getOfferAmount(),
proto.getOfferMinAmount(),
proto.getOfferId(),
proto.getTradePrice(),
proto.getTradeAmount(),
proto.getTradeDate(),
proto.getDepositTxId(),
PubKeyRing.fromProto(proto.getPubKeyRing()),
CollectionUtils.isEmpty(proto.getExtraDataMap()) ? null : proto.getExtraDataMap());
}
@ -171,11 +168,6 @@ public final class TradeStatistics implements LazyProcessedStoragePayload, /*Cap
// Getters
///////////////////////////////////////////////////////////////////////////////////////////
@Override
public long getTTL() {
return TTL;
}
@Override
public PublicKey getOwnerPubKey() {
return pubKeyRing.getSignaturePubKey();
@ -211,55 +203,4 @@ public final class TradeStatistics implements LazyProcessedStoragePayload, /*Cap
else
return new Volume(new ExchangeRate((Fiat) getTradePrice().getMonetary()).coinToFiat(getTradeAmount()));
}
// We don't include the pubKeyRing as both traders might publish it if the maker uses an old
// version and update later (taker publishes first, then later maker)
// We also don't include the trade date as that is set locally and different for maker and taker
@Override
public int hashCode() {
int result;
long temp;
result = baseCurrency != null ? baseCurrency.hashCode() : 0;
result = 31 * result + (counterCurrency != null ? counterCurrency.hashCode() : 0);
result = 31 * result + (direction != null ? direction.hashCode() : 0);
result = 31 * result + (int) (tradePrice ^ (tradePrice >>> 32));
result = 31 * result + (int) (tradeAmount ^ (tradeAmount >>> 32));
result = 31 * result + (paymentMethodId != null ? paymentMethodId.hashCode() : 0);
result = 31 * result + (int) (offerDate ^ (offerDate >>> 32));
result = 31 * result + (useMarketBasedPrice ? 1 : 0);
temp = Double.doubleToLongBits(marketPriceMargin);
result = 31 * result + (int) (temp ^ (temp >>> 32));
result = 31 * result + (int) (offerAmount ^ (offerAmount >>> 32));
result = 31 * result + (int) (offerMinAmount ^ (offerMinAmount >>> 32));
result = 31 * result + (offerId != null ? offerId.hashCode() : 0);
result = 31 * result + (depositTxId != null ? depositTxId.hashCode() : 0);
result = 31 * result + (extraDataMap != null ? extraDataMap.hashCode() : 0);
return result;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
TradeStatistics that = (TradeStatistics) o;
if (tradePrice != that.tradePrice) return false;
if (tradeAmount != that.tradeAmount) return false;
if (offerDate != that.offerDate) return false;
if (useMarketBasedPrice != that.useMarketBasedPrice) return false;
if (Double.compare(that.marketPriceMargin, marketPriceMargin) != 0) return false;
if (offerAmount != that.offerAmount) return false;
if (offerMinAmount != that.offerMinAmount) return false;
if (baseCurrency != null ? !baseCurrency.equals(that.baseCurrency) : that.baseCurrency != null) return false;
if (counterCurrency != null ? !counterCurrency.equals(that.counterCurrency) : that.counterCurrency != null)
return false;
if (direction != that.direction) return false;
if (paymentMethodId != null ? !paymentMethodId.equals(that.paymentMethodId) : that.paymentMethodId != null)
return false;
if (offerId != null ? !offerId.equals(that.offerId) : that.offerId != null) return false;
if (depositTxId != null ? !depositTxId.equals(that.depositTxId) : that.depositTxId != null) return false;
return !(extraDataMap != null ? !extraDataMap.equals(that.extraDataMap) : that.extraDataMap != null);
}
}

106
core/src/main/java/io/bisq/core/trade/statistics/TradeStatisticsForJson.java
View file

@ -5,15 +5,18 @@ import io.bisq.common.monetary.Price;
import io.bisq.common.monetary.Volume;
import io.bisq.common.util.MathUtils;
import io.bisq.core.offer.OfferPayload;
import lombok.EqualsAndHashCode;
import lombok.ToString;
import lombok.extern.slf4j.Slf4j;
import org.bitcoinj.core.Coin;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.concurrent.Immutable;
@Immutable
@EqualsAndHashCode
@ToString
@Slf4j
public final class TradeStatisticsForJson {
private static final Logger log = LoggerFactory.getLogger(TradeStatisticsForJson.class);
public final String currency;
public final OfferPayload.Direction direction;
@ -37,21 +40,20 @@ public final class TradeStatisticsForJson {
public long primaryMarketTradeAmount;
public long primaryMarketTradeVolume;
public TradeStatisticsForJson(TradeStatistics tradeStatistics) {
this.direction = OfferPayload.Direction.valueOf(tradeStatistics.direction.name());
this.direction = OfferPayload.Direction.valueOf(tradeStatistics.getDirection().name());
this.currency = tradeStatistics.getCurrencyCode();
this.paymentMethod = tradeStatistics.paymentMethodId;
this.offerDate = tradeStatistics.offerDate;
this.useMarketBasedPrice = tradeStatistics.useMarketBasedPrice;
this.marketPriceMargin = tradeStatistics.marketPriceMargin;
this.offerAmount = tradeStatistics.offerAmount;
this.offerMinAmount = tradeStatistics.offerMinAmount;
this.paymentMethod = tradeStatistics.getOfferPaymentMethod();
this.offerDate = tradeStatistics.getOfferDate();
this.useMarketBasedPrice = tradeStatistics.isOfferUseMarketBasedPrice();
this.marketPriceMargin = tradeStatistics.getOfferMarketPriceMargin();
this.offerAmount = tradeStatistics.getOfferAmount();
this.offerMinAmount = tradeStatistics.getOfferMinAmount();
this.offerId = tradeStatistics.getOfferId();
this.tradePrice = tradeStatistics.tradePrice;
this.tradeAmount = tradeStatistics.tradeAmount;
this.tradeDate = tradeStatistics.tradeDate;
this.depositTxId = tradeStatistics.depositTxId;
this.tradePrice = tradeStatistics.getTradePrice().getValue();
this.tradeAmount = tradeStatistics.getTradeAmount().getValue();
this.tradeDate = tradeStatistics.getTradeDate().getTime();
this.depositTxId = tradeStatistics.getDepositTxId();
try {
@ -77,12 +79,11 @@ public final class TradeStatisticsForJson {
(long) MathUtils.scaleUpByPowerOf10(getTradeVolume().getValue(), 4) : 0;
}
} catch (Throwable t) {
log.error("Error at setDisplayStrings: " + t.getMessage());
log.error(t.getMessage());
t.printStackTrace();
}
}
public Price getTradePrice() {
return Price.valueOf(currency, tradePrice);
}
@ -94,75 +95,4 @@ public final class TradeStatisticsForJson {
public Volume getTradeVolume() {
return getTradePrice().getVolumeByAmount(getTradeAmount());
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof TradeStatisticsForJson)) return false;
TradeStatisticsForJson that = (TradeStatisticsForJson) o;
if (tradePrice != that.tradePrice) return false;
if (tradeAmount != that.tradeAmount) return false;
if (tradeDate != that.tradeDate) return false;
if (offerDate != that.offerDate) return false;
if (useMarketBasedPrice != that.useMarketBasedPrice) return false;
if (Double.compare(that.marketPriceMargin, marketPriceMargin) != 0) return false;
if (offerAmount != that.offerAmount) return false;
if (offerMinAmount != that.offerMinAmount) return false;
if (currency != null ? !currency.equals(that.currency) : that.currency != null) return false;
if (direction != that.direction) return false;
if (paymentMethod != null ? !paymentMethod.equals(that.paymentMethod) : that.paymentMethod != null)
return false;
if (offerId != null ? !offerId.equals(that.offerId) : that.offerId != null) return false;
return !(depositTxId != null ? !depositTxId.equals(that.depositTxId) : that.depositTxId != null);
}
@Override
public int hashCode() {
int result;
long temp;
result = currency != null ? currency.hashCode() : 0;
result = 31 * result + (direction != null ? direction.hashCode() : 0);
result = 31 * result + (int) (tradePrice ^ (tradePrice >>> 32));
result = 31 * result + (int) (tradeAmount ^ (tradeAmount >>> 32));
result = 31 * result + (int) (tradeDate ^ (tradeDate >>> 32));
result = 31 * result + (paymentMethod != null ? paymentMethod.hashCode() : 0);
result = 31 * result + (int) (offerDate ^ (offerDate >>> 32));
result = 31 * result + (useMarketBasedPrice ? 1 : 0);
temp = Double.doubleToLongBits(marketPriceMargin);
result = 31 * result + (int) (temp ^ (temp >>> 32));
result = 31 * result + (int) (offerAmount ^ (offerAmount >>> 32));
result = 31 * result + (int) (offerMinAmount ^ (offerMinAmount >>> 32));
result = 31 * result + (offerId != null ? offerId.hashCode() : 0);
result = 31 * result + (depositTxId != null ? depositTxId.hashCode() : 0);
result = 31 * result + (currencyPair != null ? currencyPair.hashCode() : 0);
result = 31 * result + (primaryMarketDirection != null ? primaryMarketDirection.hashCode() : 0);
result = 31 * result + (int) (primaryMarketTradePrice ^ (primaryMarketTradePrice >>> 32));
result = 31 * result + (int) (primaryMarketTradeAmount ^ (primaryMarketTradeAmount >>> 32));
result = 31 * result + (int) (primaryMarketTradeVolume ^ (primaryMarketTradeVolume >>> 32));
return result;
}
@Override
public String toString() {
return "TradeStatisticsForJson{" +
"currency='" + currency + '\'' +
", direction=" + direction +
", tradePrice=" + tradePrice +
", tradeAmount=" + tradeAmount +
", tradeDate=" + tradeDate +
", paymentMethod='" + paymentMethod + '\'' +
", offerDate=" + offerDate +
", useMarketBasedPrice=" + useMarketBasedPrice +
", marketPriceMargin=" + marketPriceMargin +
", offerAmount=" + offerAmount +
", offerMinAmount=" + offerMinAmount +
", offerId='" + offerId + '\'' +
", depositTxId='" + depositTxId + '\'' +
", currencyPair='" + currencyPair + '\'' +
", primaryMarketTradeAmount=" + primaryMarketTradeAmount +
", primaryMarketTradeVolume=" + primaryMarketTradeVolume +
'}';
}
}

26
core/src/main/java/io/bisq/core/user/UserPayload.java
View file

@ -85,20 +85,18 @@ public class UserPayload implements PersistableEnvelope {
return PB.PersistableEnvelope.newBuilder().setUserPayload(builder).build();
}
public static UserPayload fromProto(PB.UserPayload user) {
Set<PaymentAccount> collect = user.getPaymentAccountsList().stream().map(paymentAccount -> PaymentAccount.fromProto(paymentAccount)).collect(Collectors.toSet());
UserPayload vo = new UserPayload(user.getAccountId(),
collect,
user.hasCurrentPaymentAccount() ? PaymentAccount.fromProto(user.getCurrentPaymentAccount()) : null,
user.getAcceptedLanguageLocaleCodesList(),
user.hasDevelopersAlert() ? Alert.fromProto(user.getDevelopersAlert()) : null,
user.hasDisplayedAlert() ? Alert.fromProto(user.getDisplayedAlert()) : null,
user.hasDevelopersFilter() ? Filter.fromProto(user.getDevelopersFilter()) : null,
user.hasRegisteredArbitrator() ? Arbitrator.fromProto(user.getRegisteredArbitrator()) : null,
user.hasRegisteredMediator() ? Mediator.fromProto(user.getRegisteredMediator()) : null,
user.getAcceptedArbitratorsList().stream().map(Arbitrator::fromProto).collect(Collectors.toList()),
user.getAcceptedMediatorsList().stream().map(Mediator::fromProto).collect(Collectors.toList())
public static UserPayload fromProto(PB.UserPayload proto) {
return new UserPayload(proto.getAccountId(),
proto.getPaymentAccountsList().stream().map(PaymentAccount::fromProto).collect(Collectors.toSet()),
proto.hasCurrentPaymentAccount() ? PaymentAccount.fromProto(proto.getCurrentPaymentAccount()) : null,
proto.getAcceptedLanguageLocaleCodesList(),
proto.hasDevelopersAlert() ? Alert.fromProto(proto.getDevelopersAlert()) : null,
proto.hasDisplayedAlert() ? Alert.fromProto(proto.getDisplayedAlert()) : null,
proto.hasDevelopersFilter() ? Filter.fromProto(proto.getDevelopersFilter()) : null,
proto.hasRegisteredArbitrator() ? Arbitrator.fromProto(proto.getRegisteredArbitrator()) : null,
proto.hasRegisteredMediator() ? Mediator.fromProto(proto.getRegisteredMediator()) : null,
proto.getAcceptedArbitratorsList().stream().map(Arbitrator::fromProto).collect(Collectors.toList()),
proto.getAcceptedMediatorsList().stream().map(Mediator::fromProto).collect(Collectors.toList())
);
return vo;
}
}

2
core/src/test/java/io/bisq/core/arbitration/ArbitratorTest.java
View file

@ -43,7 +43,7 @@ public class ArbitratorTest {
new Date(),
getBytes(100),
"registrationSignature",
"string", null);
null, null, null);
}
// TODO move to common if used often

1
gui/src/main/java/io/bisq/gui/main/account/arbitratorregistration/ArbitratorRegistrationViewModel.java
View file

@ -157,6 +157,7 @@ class ArbitratorRegistrationViewModel extends ActivatableViewModel {
registrationKey.getPubKey(),
registrationSignature,
emailAddress,
null,
null
);

6
gui/src/main/java/io/bisq/gui/main/dao/voting/vote/ParameterViewItem.java
View file

@ -63,7 +63,7 @@ public class ParameterViewItem {
}
public static boolean contains(VoteItem selectedItem) {
return instances.stream().filter(e -> e.voteItem.votingType == selectedItem.votingType).findAny().isPresent();
return instances.stream().filter(e -> e.voteItem.getVotingType() == selectedItem.getVotingType()).findAny().isPresent();
}
public static boolean isEmpty() {
@ -72,12 +72,12 @@ public class ParameterViewItem {
private ParameterViewItem(VoteItem voteItem, VBox vBox, DoubleProperty labelWidth, VotingDefaultValues votingDefaultValues, Runnable removeHandler) {
this.voteItem = voteItem;
originalValue = votingDefaultValues.getValueByVotingType(voteItem.votingType);
originalValue = votingDefaultValues.getValueByVotingType(voteItem.getVotingType());
HBox hBox = new HBox();
hBox.setSpacing(5);
vBox.getChildren().add(hBox);
label = new Label(voteItem.name + ":");
label = new Label(voteItem.getName() + ":");
HBox.setMargin(label, new Insets(4, 0, 0, 0));
numberChangeListener = (observable, oldValue, newValue) -> {
if ((double) newValue > 0) {

2
gui/src/main/java/io/bisq/gui/main/dao/voting/vote/VoteView.java
View file

@ -141,7 +141,7 @@ public class VoteView extends ActivatableView<GridPane, Void> {
parametersComboBox.setConverter(new StringConverter<VoteItem>() {
@Override
public String toString(VoteItem item) {
return item.name;
return item.getName();
}
@Override

4
gui/src/main/java/io/bisq/gui/main/market/trades/TradesChartsView.java
View file

@ -648,12 +648,12 @@ public class TradesChartsView extends ActivatableViewAndModel<VBox, TradesCharts
@NotNull
private String getDirectionLabel(TradeStatistics item) {
return formatter.getDirectionWithCode(OfferPayload.Direction.valueOf(item.direction.name()), item.getCurrencyCode());
return formatter.getDirectionWithCode(OfferPayload.Direction.valueOf(item.getDirection().name()), item.getCurrencyCode());
}
@NotNull
private String getPaymentMethodLabel(TradeStatistics item) {
return Res.get(item.paymentMethodId);
return Res.get(item.getOfferPaymentMethod());
}
private void layout() {

12
gui/src/main/java/io/bisq/gui/main/market/trades/TradesChartsViewModel.java
View file

@ -248,7 +248,7 @@ class TradesChartsViewModel extends ActivatableViewModel {
final long dateAsTime = new Date().getTime();
tradeStatisticsByCurrency.stream().forEach(e -> {
Set<TradeStatistics> set;
final long time = getTickFromTime(e.tradeDate, tickUnit);
final long time = getTickFromTime(e.getTradeDate().getTime(), tickUnit);
final long now = getTickFromTime(dateAsTime, tickUnit);
long index = maxTicks - (now - time);
if (itemsPerInterval.containsKey(index)) {
@ -289,7 +289,7 @@ class TradesChartsViewModel extends ActivatableViewModel {
long numTrades = set.size();
for (TradeStatistics item : set) {
long tradePriceAsLong = item.tradePrice;
long tradePriceAsLong = item.getTradePrice().getValue();
if (CurrencyUtil.isCryptoCurrency(getCurrencyCode())) {
low = (low != 0) ? Math.max(low, tradePriceAsLong) : tradePriceAsLong;
high = (high != 0) ? Math.min(high, tradePriceAsLong) : tradePriceAsLong;
@ -299,14 +299,14 @@ class TradesChartsViewModel extends ActivatableViewModel {
}
accumulatedVolume += (item.getTradeVolume() != null) ? item.getTradeVolume().getValue() : 0;
accumulatedAmount += item.tradeAmount;
accumulatedAmount += item.getTradeAmount().getValue();
}
List<TradeStatistics> list = new ArrayList<>(set);
list.sort((o1, o2) -> (o1.tradeDate < o2.tradeDate ? -1 : (o1.tradeDate == o2.tradeDate ? 0 : 1)));
list.sort((o1, o2) -> (o1.getTradeDate().getTime() < o2.getTradeDate().getTime() ? -1 : (o1.getTradeDate().getTime() == o2.getTradeDate().getTime() ? 0 : 1)));
if (list.size() > 0) {
open = list.get(0).tradePrice;
close = list.get(list.size() - 1).tradePrice;
open = list.get(0).getTradePrice().getValue();
close = list.get(list.size() - 1).getTradePrice().getValue();
}
long averagePrice;

4
gui/src/main/java/io/bisq/gui/main/offer/offerbook/OfferBookViewModel.java
View file

@ -451,7 +451,7 @@ class OfferBookViewModel extends ActivatableViewModel {
boolean isOfferBanned(Offer offer) {
return filterManager.getFilter() != null &&
filterManager.getFilter().bannedOfferIds.stream()
filterManager.getFilter().getBannedOfferIds().stream()
.filter(e -> e.equals(offer.getId()))
.findAny()
.isPresent();
@ -459,7 +459,7 @@ class OfferBookViewModel extends ActivatableViewModel {
boolean isNodeBanned(Offer offer) {
return filterManager.getFilter() != null &&
filterManager.getFilter().bannedNodeAddress.stream()
filterManager.getFilter().getBannedNodeAddress().stream()
.filter(e -> e.equals(offer.getMakerNodeAddress().getHostNameWithoutPostFix()))
.findAny()
.isPresent();

16
gui/src/main/java/io/bisq/gui/main/overlays/windows/FilterWindow.java
View file

@ -119,17 +119,17 @@ public class FilterWindow extends Overlay<FilterWindow> {
final Filter filter = filterManager.getDevelopersFilter();
if (filter != null) {
offerIdsInputTextField.setText(filter.bannedOfferIds.stream().collect(Collectors.joining(", ")));
nodesInputTextField.setText(filter.bannedNodeAddress.stream().collect(Collectors.joining(", ")));
if (filter.bannedPaymentAccounts != null) {
offerIdsInputTextField.setText(filter.getBannedOfferIds().stream().collect(Collectors.joining(", ")));
nodesInputTextField.setText(filter.getBannedNodeAddress().stream().collect(Collectors.joining(", ")));
if (filter.getBannedPaymentAccounts() != null) {
StringBuilder sb = new StringBuilder();
filter.bannedPaymentAccounts.stream().forEach(e -> {
if (e != null && e.paymentMethodId != null) {
sb.append(e.paymentMethodId)
filter.getBannedPaymentAccounts().stream().forEach(e -> {
if (e != null && e.getPaymentMethodId() != null) {
sb.append(e.getPaymentMethodId())
.append("|")
.append(e.getMethodName)
.append(e.getGetMethodName())
.append("|")
.append(e.value)
.append(e.getValue())
.append(", ");
}
});

9
network/src/main/java/io/bisq/network/p2p/PrefixedSealedAndSignedMessage.java
View file

@ -1,7 +1,6 @@
package io.bisq.network.p2p;
import com.google.protobuf.ByteString;
import io.bisq.common.app.Version;
import io.bisq.common.crypto.SealedAndSigned;
import io.bisq.common.proto.network.NetworkEnvelope;
import io.bisq.generated.protobuffer.PB;
@ -11,7 +10,6 @@ import static com.google.common.base.Preconditions.checkNotNull;
@Value
public final class PrefixedSealedAndSignedMessage implements MailboxMessage, SendersNodeAddressMessage {
private final int messageVersion = Version.getP2PMessageVersion();
private final NodeAddress senderNodeAddress;
private final SealedAndSigned sealedAndSigned;
private final byte[] addressPrefixHash;
@ -21,7 +19,7 @@ public final class PrefixedSealedAndSignedMessage implements MailboxMessage, Sen
SealedAndSigned sealedAndSigned,
byte[] addressPrefixHash,
String uid) {
checkNotNull(senderNodeAddress, "senderNodeAddress must not be null at PrefixedSealedAndSignedMessage");
checkNotNull(senderNodeAddress, "senderNodeAddress must not be null");
this.senderNodeAddress = senderNodeAddress;
this.sealedAndSigned = sealedAndSigned;
this.addressPrefixHash = addressPrefixHash;
@ -32,10 +30,11 @@ public final class PrefixedSealedAndSignedMessage implements MailboxMessage, Sen
public PB.NetworkEnvelope toProtoNetworkEnvelope() {
return NetworkEnvelope.getDefaultBuilder().setPrefixedSealedAndSignedMessage(
PB.PrefixedSealedAndSignedMessage.newBuilder()
.setMessageVersion(messageVersion).setNodeAddress(senderNodeAddress.toProtoMessage())
.setNodeAddress(senderNodeAddress.toProtoMessage())
.setSealedAndSigned(sealedAndSigned.toProtoMessage())
.setAddressPrefixHash(ByteString.copyFrom(addressPrefixHash))
.setUid(uid)).build();
.setUid(uid))
.build();
}
public static PrefixedSealedAndSignedMessage fromProto(PB.PrefixedSealedAndSignedMessage proto) {

18
network/src/main/java/io/bisq/network/p2p/storage/P2PDataStorage.java
View file

@ -28,6 +28,7 @@ import io.bisq.network.p2p.storage.messages.*;
import io.bisq.network.p2p.storage.payload.*;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.ToString;
import org.apache.commons.lang3.StringUtils;
import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger;
@ -731,8 +732,8 @@ public class P2PDataStorage implements MessageListener, ConnectionListener {
return PB.ByteArray.newBuilder().setBytes(ByteString.copyFrom(bytes)).build();
}
public static ByteArray fromProto(PB.ByteArray byteArray) {
return new ByteArray(byteArray.getBytes().toByteArray());
public static ByteArray fromProto(PB.ByteArray proto) {
return new ByteArray(proto.getBytes().toByteArray());
}
}
@ -740,6 +741,7 @@ public class P2PDataStorage implements MessageListener, ConnectionListener {
* Used as value in map
*/
@EqualsAndHashCode
@ToString
public static final class MapValue implements PersistablePayload {
// That object is saved to disc. We need to take care of changes to not break deserialization.
final public int sequenceNr;
@ -750,21 +752,13 @@ public class P2PDataStorage implements MessageListener, ConnectionListener {
this.timeStamp = timeStamp;
}
@Override
public String toString() {
return "MapValue{" +
"sequenceNr=" + sequenceNr +
", timeStamp=" + timeStamp +
'}';
}
@Override
public PB.MapValue toProtoMessage() {
return PB.MapValue.newBuilder().setSequenceNr(sequenceNr).setTimeStamp(timeStamp).build();
}
public static MapValue fromProto(PB.MapValue value) {
return new MapValue(value.getSequenceNr(), value.getTimeStamp());
public static MapValue fromProto(PB.MapValue proto) {
return new MapValue(proto.getSequenceNr(), proto.getTimeStamp());
}
}
}

38
network/src/main/java/io/bisq/network/p2p/storage/SequenceNumberMap.java
View file

@ -24,7 +24,6 @@ import lombok.Setter;
import lombok.experimental.Delegate;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
@ -44,8 +43,8 @@ public class SequenceNumberMap implements PersistableEnvelope {
public SequenceNumberMap() {
}
public SequenceNumberMap(SequenceNumberMap sequenceNumberMap) {
this.hashMap = sequenceNumberMap.getHashMap();
public SequenceNumberMap(SequenceNumberMap map) {
this.hashMap = map.getHashMap();
}
public SequenceNumberMap(HashMap<P2PDataStorage.ByteArray, P2PDataStorage.MapValue> hashMap) {
@ -57,25 +56,28 @@ public class SequenceNumberMap implements PersistableEnvelope {
return PB.PersistableEnvelope.newBuilder().setSequenceNumberMap(
PB.SequenceNumberMap.newBuilder().addAllSequenceNumberEntries(
hashMap.entrySet().stream()
.map(entry ->
PB.SequenceNumberEntry.newBuilder().setBytes(entry.getKey().toProtoMessage())
.setMapValue(entry.getValue().toProtoMessage()).build())
.collect(Collectors.toList()))).build();
.map(entry -> PB.SequenceNumberEntry.newBuilder()
.setBytes(entry.getKey().toProtoMessage())
.setMapValue(entry.getValue().toProtoMessage())
.build())
.collect(Collectors.toList())))
.build();
}
public static SequenceNumberMap fromProto(PB.SequenceNumberMap sequenceNumberMap) {
List<PB.SequenceNumberEntry> sequenceNumberEntryList = sequenceNumberMap.getSequenceNumberEntriesList();
HashMap<P2PDataStorage.ByteArray, P2PDataStorage.MapValue> result = new HashMap<>();
for (final PB.SequenceNumberEntry entry : sequenceNumberEntryList) {
result.put(P2PDataStorage.ByteArray.fromProto(entry.getBytes()), P2PDataStorage.MapValue.fromProto(entry.getMapValue()));
}
return new SequenceNumberMap(result);
public static SequenceNumberMap fromProto(PB.SequenceNumberMap proto) {
HashMap<P2PDataStorage.ByteArray, P2PDataStorage.MapValue> map = new HashMap<>();
proto.getSequenceNumberEntriesList().stream().forEach(entry -> {
map.put(P2PDataStorage.ByteArray.fromProto(entry.getBytes()), P2PDataStorage.MapValue.fromProto(entry.getMapValue()));
});
return new SequenceNumberMap(map);
}
// avoid warnings in IDE, because of type erasure intellij thinks there are duplicate methods generated by lombok delegate
private interface ExcludeFromDelegate<K,V> {
public void forEach(BiConsumer<? super P2PDataStorage.ByteArray, ? super P2PDataStorage.MapValue> action);
public void putAll(Map<? extends P2PDataStorage.ByteArray, ? extends P2PDataStorage.MapValue> all);
public void replaceAll(BiFunction<? super P2PDataStorage.ByteArray, ? super P2PDataStorage.MapValue, ? extends P2PDataStorage.MapValue> all);
private interface ExcludeFromDelegate<K, V> {
void forEach(BiConsumer<? super P2PDataStorage.ByteArray, ? super P2PDataStorage.MapValue> action);
void putAll(Map<? extends P2PDataStorage.ByteArray, ? extends P2PDataStorage.MapValue> all);
void replaceAll(BiFunction<? super P2PDataStorage.ByteArray, ? super P2PDataStorage.MapValue, ? extends P2PDataStorage.MapValue> all);
}
}

13
network/src/main/java/io/bisq/network/p2p/storage/payload/MailboxStoragePayload.java
View file

@ -2,7 +2,6 @@ package io.bisq.network.p2p.storage.payload;
import com.google.protobuf.ByteString;
import io.bisq.common.crypto.Sig;
import io.bisq.common.proto.network.NetworkProtoResolver;
import io.bisq.generated.protobuffer.PB;
import io.bisq.network.p2p.PrefixedSealedAndSignedMessage;
import lombok.EqualsAndHashCode;
@ -29,7 +28,6 @@ import java.util.concurrent.TimeUnit;
@Slf4j
public final class MailboxStoragePayload implements StoragePayload {
private final long TTL = TimeUnit.DAYS.toMillis(10);
private final PrefixedSealedAndSignedMessage prefixedSealedAndSignedMessage;
private PublicKey senderPubKeyForAddOperation;
private final byte[] senderPubKeyForAddOperationBytes;
@ -50,10 +48,9 @@ public final class MailboxStoragePayload implements StoragePayload {
senderPubKeyForAddOperationBytes = Sig.getSigPublicKeyBytes(senderPubKeyForAddOperation);
ownerPubKeyBytes = Sig.getSigPublicKeyBytes(ownerPubKey);
this.extraDataMap = null;
}
public MailboxStoragePayload(PrefixedSealedAndSignedMessage prefixedSealedAndSignedMessage,
private MailboxStoragePayload(PrefixedSealedAndSignedMessage prefixedSealedAndSignedMessage,
byte[] senderPubKeyForAddOperationBytes,
byte[] ownerPubKeyBytes,
@Nullable Map<String, String> extraDataMap) {
@ -72,17 +69,15 @@ public final class MailboxStoragePayload implements StoragePayload {
.setPrefixedSealedAndSignedMessage(prefixedSealedAndSignedMessage.toProtoNetworkEnvelope().getPrefixedSealedAndSignedMessage())
.setSenderPubKeyForAddOperationBytes(ByteString.copyFrom(senderPubKeyForAddOperationBytes))
.setOwnerPubKeyBytes(ByteString.copyFrom(ownerPubKeyBytes));
Optional.ofNullable(extraDataMap).ifPresent(builder::putAllExtraDataMap);
Optional.ofNullable(extraDataMap).ifPresent(builder::putAllExtraData);
return PB.StoragePayload.newBuilder().setMailboxStoragePayload(builder).build();
}
public static MailboxStoragePayload fromProto(PB.MailboxStoragePayload proto, NetworkProtoResolver networkProtoResolver) {
Map<String, String> extraDataMapMap = CollectionUtils.isEmpty(proto.getExtraDataMapMap()) ?
null : proto.getExtraDataMapMap();
public static MailboxStoragePayload fromProto(PB.MailboxStoragePayload proto) {
return new MailboxStoragePayload(
PrefixedSealedAndSignedMessage.fromProto(proto.getPrefixedSealedAndSignedMessage()),
proto.getSenderPubKeyForAddOperationBytes().toByteArray(),
proto.getOwnerPubKeyBytes().toByteArray(),
extraDataMapMap);
CollectionUtils.isEmpty(proto.getExtraDataMap()) ? null : proto.getExtraDataMap());
}
}

1
network/src/main/java/io/bisq/network/p2p/storage/payload/ProtectedStorageEntry.java
View file

@ -75,6 +75,7 @@ public class ProtectedStorageEntry implements NetworkPayload, PersistablePayload
proto.getSignature().toByteArray());
}
///////////////////////////////////////////////////////////////////////////////////////////
// API
///////////////////////////////////////////////////////////////////////////////////////////