getFundingAddresses() {
.collect(Collectors.toList());
}
+ String getUnusedBsqAddress() {
+ return bsqWalletService.getUnusedBsqAddressAsString();
+ }
+
+ void sendBsq(String address,
+ double amount,
+ TxBroadcaster.Callback callback) {
+ try {
+ LegacyAddress legacyAddress = getValidBsqLegacyAddress(address);
+ Coin receiverAmount = getValidBsqTransferAmount(amount);
+ BsqTransferModel model = bsqTransferService.getBsqTransferModel(legacyAddress, receiverAmount);
+ bsqTransferService.sendFunds(model, callback);
+ } catch (InsufficientMoneyException
+ | BsqChangeBelowDustException
+ | TransactionVerificationException
+ | WalletException ex) {
+ log.error("", ex);
+ throw new IllegalStateException(ex);
+ }
+ }
+
int getNumConfirmationsForMostRecentTransaction(String addressString) {
Address address = getAddressEntry(addressString).getAddress();
TransactionConfidence confidence = btcWalletService.getConfidenceForAddress(address);
@@ -244,6 +307,76 @@ private void verifyEncryptedWalletIsUnlocked() {
throw new IllegalStateException("wallet is locked");
}
+ // Throws a RuntimeException if wallet currency code is not BSQ or BTC.
+ private void verifyWalletCurrencyCodeIsValid(String currencyCode) {
+ if (currencyCode == null || currencyCode.isEmpty())
+ return;
+
+ if (!currencyCode.equalsIgnoreCase("BSQ")
+ && !currencyCode.equalsIgnoreCase("BTC"))
+ throw new IllegalStateException(format("wallet does not support %s", currencyCode));
+ }
+
+ private BsqBalanceInfo getBsqBalances() {
+ verifyWalletsAreAvailable();
+ verifyEncryptedWalletIsUnlocked();
+
+ var availableConfirmedBalance = bsqWalletService.getAvailableConfirmedBalance();
+ var unverifiedBalance = bsqWalletService.getUnverifiedBalance();
+ var unconfirmedChangeBalance = bsqWalletService.getUnconfirmedChangeBalance();
+ var lockedForVotingBalance = bsqWalletService.getLockedForVotingBalance();
+ var lockupBondsBalance = bsqWalletService.getLockupBondsBalance();
+ var unlockingBondsBalance = bsqWalletService.getUnlockingBondsBalance();
+
+ return new BsqBalanceInfo(availableConfirmedBalance.value,
+ unverifiedBalance.value,
+ unconfirmedChangeBalance.value,
+ lockedForVotingBalance.value,
+ lockupBondsBalance.value,
+ unlockingBondsBalance.value);
+ }
+
+ private BtcBalanceInfo getBtcBalances() {
+ verifyWalletsAreAvailable();
+ verifyEncryptedWalletIsUnlocked();
+
+ var availableBalance = balances.getAvailableBalance().get();
+ if (availableBalance == null)
+ throw new IllegalStateException("balance is not yet available");
+
+ var reservedBalance = balances.getReservedBalance().get();
+ if (reservedBalance == null)
+ throw new IllegalStateException("reserved balance is not yet available");
+
+ var lockedBalance = balances.getLockedBalance().get();
+ if (lockedBalance == null)
+ throw new IllegalStateException("locked balance is not yet available");
+
+ return new BtcBalanceInfo(availableBalance.value,
+ reservedBalance.value,
+ availableBalance.add(reservedBalance).value,
+ lockedBalance.value);
+ }
+
+ // Returns a LegacyAddress for the string, or a RuntimeException if invalid.
+ private LegacyAddress getValidBsqLegacyAddress(String address) {
+ try {
+ return bsqFormatter.getAddressFromBsqAddress(address);
+ } catch (Throwable t) {
+ log.error("", t);
+ throw new IllegalStateException(format("%s is not a valid bsq address", address));
+ }
+ }
+
+ // Returns a Coin for the double amount, or a RuntimeException if invalid.
+ private Coin getValidBsqTransferAmount(double amount) {
+ Coin amountAsCoin = parseToCoin(Double.toString(amount), bsqFormatter);
+ if (amountAsCoin.equals(Coin.ZERO))
+ throw new IllegalStateException(format("%.2f bsq is an invalid send amount", amount));
+
+ return amountAsCoin;
+ }
+
private KeyCrypterScrypt getKeyCrypterScrypt() {
KeyCrypterScrypt keyCrypterScrypt = walletsManager.getKeyCrypterScrypt();
if (keyCrypterScrypt == null)
diff --git a/core/src/main/java/bisq/core/api/model/BalancesInfo.java b/core/src/main/java/bisq/core/api/model/BalancesInfo.java
new file mode 100644
index 00000000000..3b063bc0d2b
--- /dev/null
+++ b/core/src/main/java/bisq/core/api/model/BalancesInfo.java
@@ -0,0 +1,45 @@
+package bisq.core.api.model;
+
+import bisq.common.Payload;
+
+import lombok.Getter;
+
+@Getter
+public class BalancesInfo implements Payload {
+
+ // Getter names are shortened for readability's sake, i.e.,
+ // balancesInfo.getBtc().getAvailableBalance() is cleaner than
+ // balancesInfo.getBtcBalanceInfo().getAvailableBalance().
+ private final BsqBalanceInfo bsq;
+ private final BtcBalanceInfo btc;
+
+ public BalancesInfo(BsqBalanceInfo bsq, BtcBalanceInfo btc) {
+ this.bsq = bsq;
+ this.btc = btc;
+ }
+
+ ///////////////////////////////////////////////////////////////////////////////////////////
+ // PROTO BUFFER
+ ///////////////////////////////////////////////////////////////////////////////////////////
+
+ @Override
+ public bisq.proto.grpc.BalancesInfo toProtoMessage() {
+ return bisq.proto.grpc.BalancesInfo.newBuilder()
+ .setBsq(bsq.toProtoMessage())
+ .setBtc(btc.toProtoMessage())
+ .build();
+ }
+
+ public static BalancesInfo fromProto(bisq.proto.grpc.BalancesInfo proto) {
+ return new BalancesInfo(BsqBalanceInfo.fromProto(proto.getBsq()),
+ BtcBalanceInfo.fromProto(proto.getBtc()));
+ }
+
+ @Override
+ public String toString() {
+ return "BalancesInfo{" + "\n" +
+ " " + bsq.toString() + "\n" +
+ ", " + btc.toString() + "\n" +
+ '}';
+ }
+}
diff --git a/core/src/main/java/bisq/core/api/model/BsqBalanceInfo.java b/core/src/main/java/bisq/core/api/model/BsqBalanceInfo.java
new file mode 100644
index 00000000000..23324e21f33
--- /dev/null
+++ b/core/src/main/java/bisq/core/api/model/BsqBalanceInfo.java
@@ -0,0 +1,94 @@
+package bisq.core.api.model;
+
+import bisq.common.Payload;
+
+import com.google.common.annotations.VisibleForTesting;
+
+import lombok.Getter;
+
+@Getter
+public class BsqBalanceInfo implements Payload {
+
+ public static final BsqBalanceInfo EMPTY = new BsqBalanceInfo(-1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1);
+
+ // All balances are in BSQ satoshis.
+ private final long availableConfirmedBalance;
+ private final long unverifiedBalance;
+ private final long unconfirmedChangeBalance;
+ private final long lockedForVotingBalance;
+ private final long lockupBondsBalance;
+ private final long unlockingBondsBalance;
+
+ public BsqBalanceInfo(long availableConfirmedBalance,
+ long unverifiedBalance,
+ long unconfirmedChangeBalance,
+ long lockedForVotingBalance,
+ long lockupBondsBalance,
+ long unlockingBondsBalance) {
+ this.availableConfirmedBalance = availableConfirmedBalance;
+ this.unverifiedBalance = unverifiedBalance;
+ this.unconfirmedChangeBalance = unconfirmedChangeBalance;
+ this.lockedForVotingBalance = lockedForVotingBalance;
+ this.lockupBondsBalance = lockupBondsBalance;
+ this.unlockingBondsBalance = unlockingBondsBalance;
+ }
+
+ @VisibleForTesting
+ public static BsqBalanceInfo valueOf(long availableConfirmedBalance,
+ long unverifiedBalance,
+ long unconfirmedChangeBalance,
+ long lockedForVotingBalance,
+ long lockupBondsBalance,
+ long unlockingBondsBalance) {
+ // Convenience for creating a model instance instead of a proto.
+ return new BsqBalanceInfo(availableConfirmedBalance,
+ unverifiedBalance,
+ unconfirmedChangeBalance,
+ lockedForVotingBalance,
+ lockupBondsBalance,
+ unlockingBondsBalance);
+ }
+
+ ///////////////////////////////////////////////////////////////////////////////////////////
+ // PROTO BUFFER
+ ///////////////////////////////////////////////////////////////////////////////////////////
+
+ @Override
+ public bisq.proto.grpc.BsqBalanceInfo toProtoMessage() {
+ return bisq.proto.grpc.BsqBalanceInfo.newBuilder()
+ .setAvailableConfirmedBalance(availableConfirmedBalance)
+ .setUnverifiedBalance(unverifiedBalance)
+ .setUnconfirmedChangeBalance(unconfirmedChangeBalance)
+ .setLockedForVotingBalance(lockedForVotingBalance)
+ .setLockupBondsBalance(lockupBondsBalance)
+ .setUnlockingBondsBalance(unlockingBondsBalance)
+ .build();
+
+ }
+
+ public static BsqBalanceInfo fromProto(bisq.proto.grpc.BsqBalanceInfo proto) {
+ return new BsqBalanceInfo(proto.getAvailableConfirmedBalance(),
+ proto.getUnverifiedBalance(),
+ proto.getUnconfirmedChangeBalance(),
+ proto.getLockedForVotingBalance(),
+ proto.getLockupBondsBalance(),
+ proto.getUnlockingBondsBalance());
+ }
+
+ @Override
+ public String toString() {
+ return "BsqBalanceInfo{" +
+ "availableConfirmedBalance=" + availableConfirmedBalance +
+ ", unverifiedBalance=" + unverifiedBalance +
+ ", unconfirmedChangeBalance=" + unconfirmedChangeBalance +
+ ", lockedForVotingBalance=" + lockedForVotingBalance +
+ ", lockupBondsBalance=" + lockupBondsBalance +
+ ", unlockingBondsBalance=" + unlockingBondsBalance +
+ '}';
+ }
+}
diff --git a/core/src/main/java/bisq/core/api/model/BtcBalanceInfo.java b/core/src/main/java/bisq/core/api/model/BtcBalanceInfo.java
new file mode 100644
index 00000000000..e3803b0001e
--- /dev/null
+++ b/core/src/main/java/bisq/core/api/model/BtcBalanceInfo.java
@@ -0,0 +1,75 @@
+package bisq.core.api.model;
+
+import bisq.common.Payload;
+
+import com.google.common.annotations.VisibleForTesting;
+
+import lombok.Getter;
+
+@Getter
+public class BtcBalanceInfo implements Payload {
+
+ public static final BtcBalanceInfo EMPTY = new BtcBalanceInfo(-1,
+ -1,
+ -1,
+ -1);
+
+ // All balances are in BTC satoshis.
+ private final long availableBalance;
+ private final long reservedBalance;
+ private final long totalAvailableBalance; // available + reserved
+ private final long lockedBalance;
+
+ public BtcBalanceInfo(long availableBalance,
+ long reservedBalance,
+ long totalAvailableBalance,
+ long lockedBalance) {
+ this.availableBalance = availableBalance;
+ this.reservedBalance = reservedBalance;
+ this.totalAvailableBalance = totalAvailableBalance;
+ this.lockedBalance = lockedBalance;
+ }
+
+ @VisibleForTesting
+ public static BtcBalanceInfo valueOf(long availableBalance,
+ long reservedBalance,
+ long totalAvailableBalance,
+ long lockedBalance) {
+ // Convenience for creating a model instance instead of a proto.
+ return new BtcBalanceInfo(availableBalance,
+ reservedBalance,
+ totalAvailableBalance,
+ lockedBalance);
+ }
+
+ ///////////////////////////////////////////////////////////////////////////////////////////
+ // PROTO BUFFER
+ ///////////////////////////////////////////////////////////////////////////////////////////
+
+ @Override
+ public bisq.proto.grpc.BtcBalanceInfo toProtoMessage() {
+ return bisq.proto.grpc.BtcBalanceInfo.newBuilder()
+ .setAvailableBalance(availableBalance)
+ .setReservedBalance(reservedBalance)
+ .setTotalAvailableBalance(totalAvailableBalance)
+ .setLockedBalance(lockedBalance)
+ .build();
+ }
+
+ public static BtcBalanceInfo fromProto(bisq.proto.grpc.BtcBalanceInfo proto) {
+ return new BtcBalanceInfo(proto.getAvailableBalance(),
+ proto.getReservedBalance(),
+ proto.getTotalAvailableBalance(),
+ proto.getLockedBalance());
+ }
+
+ @Override
+ public String toString() {
+ return "BtcBalanceInfo{" +
+ "availableBalance=" + availableBalance +
+ ", reservedBalance=" + reservedBalance +
+ ", totalAvailableBalance=" + totalAvailableBalance +
+ ", lockedBalance=" + lockedBalance +
+ '}';
+ }
+}
diff --git a/core/src/main/java/bisq/core/api/model/OfferInfo.java b/core/src/main/java/bisq/core/api/model/OfferInfo.java
index 219045b2762..cc11aacb1d9 100644
--- a/core/src/main/java/bisq/core/api/model/OfferInfo.java
+++ b/core/src/main/java/bisq/core/api/model/OfferInfo.java
@@ -46,6 +46,7 @@ public class OfferInfo implements Payload {
private final long volume;
private final long minVolume;
private final long buyerSecurityDeposit;
+ private final boolean isCurrencyForMakerFeeBtc;
private final String paymentAccountId; // only used when creating offer
private final String paymentMethodId;
private final String paymentMethodShortName;
@@ -67,6 +68,7 @@ public OfferInfo(OfferInfoBuilder builder) {
this.volume = builder.volume;
this.minVolume = builder.minVolume;
this.buyerSecurityDeposit = builder.buyerSecurityDeposit;
+ this.isCurrencyForMakerFeeBtc = builder.isCurrencyForMakerFeeBtc;
this.paymentAccountId = builder.paymentAccountId;
this.paymentMethodId = builder.paymentMethodId;
this.paymentMethodShortName = builder.paymentMethodShortName;
@@ -88,6 +90,7 @@ public static OfferInfo toOfferInfo(Offer offer) {
.withVolume(Objects.requireNonNull(offer.getVolume()).getValue())
.withMinVolume(Objects.requireNonNull(offer.getMinVolume()).getValue())
.withBuyerSecurityDeposit(offer.getBuyerSecurityDeposit().value)
+ .withIsCurrencyForMakerFeeBtc(offer.isCurrencyForMakerFeeBtc())
.withPaymentAccountId(offer.getMakerPaymentAccountId())
.withPaymentMethodId(offer.getPaymentMethod().getId())
.withPaymentMethodShortName(offer.getPaymentMethod().getShortName())
@@ -115,6 +118,7 @@ public bisq.proto.grpc.OfferInfo toProtoMessage() {
.setVolume(volume)
.setMinVolume(minVolume)
.setBuyerSecurityDeposit(buyerSecurityDeposit)
+ .setIsCurrencyForMakerFeeBtc(isCurrencyForMakerFeeBtc)
.setPaymentAccountId(paymentAccountId)
.setPaymentMethodId(paymentMethodId)
.setPaymentMethodShortName(paymentMethodShortName)
@@ -147,6 +151,7 @@ public static class OfferInfoBuilder {
private long volume;
private long minVolume;
private long buyerSecurityDeposit;
+ private boolean isCurrencyForMakerFeeBtc;
private String paymentAccountId;
private String paymentMethodId;
private String paymentMethodShortName;
@@ -205,6 +210,11 @@ public OfferInfoBuilder withBuyerSecurityDeposit(long buyerSecurityDeposit) {
return this;
}
+ public OfferInfoBuilder withIsCurrencyForMakerFeeBtc(boolean isCurrencyForMakerFeeBtc) {
+ this.isCurrencyForMakerFeeBtc = isCurrencyForMakerFeeBtc;
+ return this;
+ }
+
public OfferInfoBuilder withPaymentAccountId(String paymentAccountId) {
this.paymentAccountId = paymentAccountId;
return this;
diff --git a/core/src/main/java/bisq/core/api/model/PaymentAccountForm.java b/core/src/main/java/bisq/core/api/model/PaymentAccountForm.java
new file mode 100644
index 00000000000..b82656b4330
--- /dev/null
+++ b/core/src/main/java/bisq/core/api/model/PaymentAccountForm.java
@@ -0,0 +1,242 @@
+/*
+ * This file is part of Bisq.
+ *
+ * Bisq is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or (at
+ * your option) any later version.
+ *
+ * Bisq is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Bisq. If not, see .
+ */
+
+package bisq.core.api.model;
+
+import bisq.core.payment.PaymentAccount;
+import bisq.core.payment.PaymentAccountFactory;
+import bisq.core.payment.payload.PaymentMethod;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+import javax.inject.Singleton;
+
+import com.google.common.annotations.VisibleForTesting;
+
+import org.apache.commons.lang3.StringUtils;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+
+import java.util.Map;
+
+import java.lang.reflect.Type;
+
+import lombok.extern.slf4j.Slf4j;
+
+import static bisq.core.payment.payload.PaymentMethod.getPaymentMethodById;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static java.lang.String.format;
+import static java.lang.System.getProperty;
+import static java.nio.charset.StandardCharsets.UTF_8;
+
+
+/**
+ *
+ * An instance of this class can write new payment account forms (editable json files),
+ * and de-serialize edited json files into {@link bisq.core.payment.PaymentAccount}
+ * instances.
+ *
+ *
+ * Example use case: (1) ask for a blank Hal Cash account form, (2) edit it, (3) derive a
+ * {@link bisq.core.payment.HalCashAccount} instance from the edited json file.
+ *
+ *
+ *
+ * (1) Ask for a hal cash account form: Pass a {@link bisq.core.payment.payload.PaymentMethod#HAL_CASH_ID}
+ * to {@link bisq.core.api.model.PaymentAccountForm#getPaymentAccountForm(String)} to
+ * get the json Hal Cash payment account form:
+ *
+ * {
+ * "_COMMENT_": "Please do not edit the paymentMethodId field.",
+ * "paymentMethodId": "HAL_CASH",
+ * "accountName": "Your accountname",
+ * "mobileNr": "Your mobilenr"
+ * }
+ *
+ *
+ *
+ * (2) Save the Hal Cash payment account form to disk, and edit it:
+ *
+ * {
+ * "_COMMENT_": "Please do not edit the paymentMethodId field.",
+ * "paymentMethodId": "HAL_CASH",
+ * "accountName": "Hal Cash Acct",
+ * "mobileNr": "798 123 456"
+ * }
+ *
+ *
+ * (3) De-serialize the edited json account form: Pass the edited json file to
+ * {@link bisq.core.api.model.PaymentAccountForm#toPaymentAccount(File)}, or
+ * a json string to {@link bisq.core.api.model.PaymentAccountForm#toPaymentAccount(String)}
+ * and get a {@link bisq.core.payment.HalCashAccount} instance.
+ *
+ * PaymentAccount(
+ * paymentMethod=PaymentMethod(id=HAL_CASH,
+ * maxTradePeriod=86400000,
+ * maxTradeLimit=50000000),
+ * id=e33c9d94-1a1a-43fd-aa11-fcaacbb46100,
+ * creationDate=Mon Nov 16 12:26:43 BRST 2020,
+ * paymentAccountPayload=HalCashAccountPayload(mobileNr=798 123 456),
+ * accountName=Hal Cash Acct,
+ * tradeCurrencies=[FiatCurrency(currency=EUR)],
+ * selectedTradeCurrency=FiatCurrency(currency=EUR)
+ * )
+ *
+ */
+@Singleton
+@Slf4j
+public class PaymentAccountForm {
+
+ private final GsonBuilder gsonBuilder = new GsonBuilder()
+ .setPrettyPrinting()
+ .serializeNulls();
+
+ // Names of PaymentAccount fields to exclude from json forms.
+ private final String[] excludedFields = new String[]{
+ "log",
+ "id",
+ "acceptedCountryCodes",
+ "countryCode",
+ "creationDate",
+ "excludeFromJsonDataMap",
+ "maxTradePeriod",
+ "paymentAccountPayload",
+ "paymentMethod",
+ "paymentMethodId",
+ "selectedTradeCurrency",
+ "tradeCurrencies",
+ "HOLDER_NAME",
+ "SALT"
+ };
+
+ /**
+ * Returns a blank payment account form (json) for the given paymentMethodId.
+ *
+ * @param paymentMethodId Determines what kind of json form to return.
+ * @return A uniquely named tmp file used to define new payment account details.
+ */
+ public File getPaymentAccountForm(String paymentMethodId) {
+ PaymentMethod paymentMethod = getPaymentMethodById(paymentMethodId);
+ File file = getTmpJsonFile(paymentMethodId);
+ try (OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(checkNotNull(file), false), UTF_8)) {
+ PaymentAccount paymentAccount = PaymentAccountFactory.getPaymentAccount(paymentMethod);
+ Class clazz = paymentAccount.getClass();
+ Gson gson = gsonBuilder.registerTypeAdapter(clazz, new PaymentAccountTypeAdapter(clazz, excludedFields)).create();
+ String json = gson.toJson(paymentAccount); // serializes target to json
+ outputStreamWriter.write(json);
+ } catch (Exception ex) {
+ String errMsg = format("cannot create a payment account form for a %s payment method", paymentMethodId);
+ log.error(StringUtils.capitalize(errMsg) + ".", ex);
+ throw new IllegalStateException(errMsg);
+ }
+ return file;
+ }
+
+ /**
+ * De-serialize a PaymentAccount json form into a new PaymentAccount instance.
+ *
+ * @param jsonForm The file representing a new payment account form.
+ * @return A populated PaymentAccount subclass instance.
+ */
+ @SuppressWarnings("unused")
+ @VisibleForTesting
+ public PaymentAccount toPaymentAccount(File jsonForm) {
+ String jsonString = toJsonString(jsonForm);
+ return toPaymentAccount(jsonString);
+ }
+
+ /**
+ * De-serialize a PaymentAccount json string into a new PaymentAccount instance.
+ *
+ * @param jsonString The json data representing a new payment account form.
+ * @return A populated PaymentAccount subclass instance.
+ */
+ public PaymentAccount toPaymentAccount(String jsonString) {
+ Class clazz = getPaymentAccountClassFromJson(jsonString);
+ Gson gson = gsonBuilder.registerTypeAdapter(clazz, new PaymentAccountTypeAdapter(clazz)).create();
+ return gson.fromJson(jsonString, clazz);
+ }
+
+ public String toJsonString(File jsonFile) {
+ try {
+ checkNotNull(jsonFile, "json file cannot be null");
+ return new String(Files.readAllBytes(Paths.get(jsonFile.getAbsolutePath())));
+ } catch (IOException ex) {
+ String errMsg = format("cannot read json string from file '%s'",
+ jsonFile.getAbsolutePath());
+ log.error(StringUtils.capitalize(errMsg) + ".", ex);
+ throw new IllegalStateException(errMsg);
+ }
+ }
+
+ @VisibleForTesting
+ public URI getClickableURI(File jsonFile) {
+ try {
+ return new URI("file",
+ "",
+ jsonFile.toURI().getPath(),
+ null,
+ null);
+ } catch (URISyntaxException ex) {
+ String errMsg = format("cannot create clickable url to file '%s'",
+ jsonFile.getAbsolutePath());
+ log.error(StringUtils.capitalize(errMsg) + ".", ex);
+ throw new IllegalStateException(errMsg);
+ }
+ }
+
+ @VisibleForTesting
+ public static File getTmpJsonFile(String paymentMethodId) {
+ File file;
+ try {
+ // Creates a tmp file that includes a random number string between the
+ // prefix and suffix, i.e., sepa_form_13243546575879.json, so there is
+ // little chance this will fail because the tmp file already exists.
+ file = File.createTempFile(paymentMethodId.toLowerCase() + "_form_",
+ ".json",
+ Paths.get(getProperty("java.io.tmpdir")).toFile());
+ } catch (IOException ex) {
+ String errMsg = format("cannot create json file for a %s payment method",
+ paymentMethodId);
+ log.error(StringUtils.capitalize(errMsg) + ".", ex);
+ throw new IllegalStateException(errMsg);
+ }
+ return file;
+ }
+
+ private Class getPaymentAccountClassFromJson(String json) {
+ Map jsonMap = gsonBuilder.create().fromJson(json, (Type) Object.class);
+ String paymentMethodId = checkNotNull((String) jsonMap.get("paymentMethodId"),
+ format("cannot not find a paymentMethodId in json string: %s", json));
+ return getPaymentAccountClass(paymentMethodId);
+ }
+
+ private Class getPaymentAccountClass(String paymentMethodId) {
+ PaymentMethod paymentMethod = getPaymentMethodById(paymentMethodId);
+ return PaymentAccountFactory.getPaymentAccount(paymentMethod).getClass();
+ }
+}
diff --git a/core/src/main/java/bisq/core/api/model/PaymentAccountTypeAdapter.java b/core/src/main/java/bisq/core/api/model/PaymentAccountTypeAdapter.java
new file mode 100644
index 00000000000..e60d5c722a7
--- /dev/null
+++ b/core/src/main/java/bisq/core/api/model/PaymentAccountTypeAdapter.java
@@ -0,0 +1,338 @@
+/*
+ * This file is part of Bisq.
+ *
+ * Bisq is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or (at
+ * your option) any later version.
+ *
+ * Bisq is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Bisq. If not, see .
+ */
+
+package bisq.core.api.model;
+
+
+import bisq.core.locale.Country;
+import bisq.core.locale.FiatCurrency;
+import bisq.core.payment.CountryBasedPaymentAccount;
+import bisq.core.payment.PaymentAccount;
+import bisq.core.payment.payload.PaymentAccountPayload;
+
+import com.google.gson.TypeAdapter;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import com.google.gson.stream.JsonWriter;
+
+import org.apache.commons.lang3.StringUtils;
+
+import java.io.IOException;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Predicate;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import lombok.extern.slf4j.Slf4j;
+
+import static bisq.common.util.ReflectionUtils.getSetterMethodForFieldInClassHierarchy;
+import static bisq.common.util.ReflectionUtils.getVisibilityModifierAsString;
+import static bisq.common.util.ReflectionUtils.isSetterOnClass;
+import static bisq.common.util.ReflectionUtils.loadFieldListForClassHierarchy;
+import static bisq.core.locale.CountryUtil.findCountryByCode;
+import static bisq.core.locale.CurrencyUtil.getCurrencyByCountryCode;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static java.lang.String.format;
+import static java.util.Comparator.comparing;
+
+@Slf4j
+class PaymentAccountTypeAdapter extends TypeAdapter {
+
+ private final Class paymentAccountType;
+ private final Class paymentAccountPayloadType;
+ private final Map> fieldSettersMap;
+ private final Predicate isExcludedField;
+
+ /**
+ * Constructor used when de-serializing a json payment account form into a
+ * PaymentAccount instance.
+ *
+ * @param paymentAccountType the PaymentAccount subclass being instantiated
+ */
+ public PaymentAccountTypeAdapter(Class paymentAccountType) {
+ this(paymentAccountType, new String[]{});
+ }
+
+ /**
+ * Constructor used when serializing a PaymentAccount subclass instance into a json
+ * payment account json form.
+ *
+ * @param paymentAccountType the PaymentAccount subclass being serialized
+ * @param excludedFields a string array of field names to exclude from the serialized
+ * payment account json form.
+ */
+ public PaymentAccountTypeAdapter(Class paymentAccountType, String[] excludedFields) {
+ this.paymentAccountType = paymentAccountType;
+ this.paymentAccountPayloadType = getPaymentAccountPayloadType();
+ this.isExcludedField = (f) -> Arrays.stream(excludedFields).anyMatch(e -> e.equals(f.getName()));
+ this.fieldSettersMap = getFieldSetterMap();
+ }
+
+ @Override
+ public void write(JsonWriter out, PaymentAccount account) throws IOException {
+ // We write a blank payment acct form for a payment method id.
+ // We're not serializing a real payment account instance here.
+ if (log.isDebugEnabled())
+ log.debug("Writing PaymentAccount json form for fields with accessors...");
+
+ out.beginObject();
+ writeCommonFields(out, account);
+ fieldSettersMap.forEach((field, value) -> {
+ try {
+ // Write out a json element if there is a @Setter for this field.
+ if (value.isPresent()) {
+ if (log.isDebugEnabled())
+ log.debug("Append form with settable field: {} {} {} setter: {}",
+ getVisibilityModifierAsString(field),
+ field.getType().getSimpleName(),
+ field.getName(),
+ value);
+
+ String fieldName = field.getName();
+ out.name(fieldName);
+ out.value("Your " + fieldName.toLowerCase());
+ }
+ } catch (Exception ex) {
+ String errMsg = format("cannot create a new %s json form",
+ account.getClass().getSimpleName());
+ log.error(StringUtils.capitalize(errMsg) + ".", ex);
+ throw new IllegalStateException("programmer error: " + errMsg);
+ }
+ });
+ out.endObject();
+ if (log.isDebugEnabled())
+ log.debug("Done writing PaymentAccount json form.");
+ }
+
+ @Override
+ public PaymentAccount read(JsonReader in) throws IOException {
+ if (log.isDebugEnabled())
+ log.debug("De-serializing json to new {} ...", paymentAccountType.getSimpleName());
+
+ PaymentAccount account = initNewPaymentAccount();
+ in.beginObject();
+ while (in.hasNext()) {
+ String currentFieldName = in.nextName();
+
+ // Some of the fields are common to all payment account types.
+ if (didReadCommonField(in, account, currentFieldName))
+ continue;
+
+ // If the account is a subclass of CountryBasedPaymentAccount, set the
+ // account's Country, and use the Country to derive and set the account's
+ // FiatCurrency.
+ if (didReadCountryField(in, account, currentFieldName))
+ continue;
+
+ Optional field = fieldSettersMap.keySet().stream()
+ .filter(k -> k.getName().equals(currentFieldName)).findFirst();
+
+ field.ifPresentOrElse((f) -> invokeSetterMethod(account, f, in), () -> {
+ throw new IllegalStateException(
+ format("programmer error: cannot de-serialize json to a '%s' "
+ + " because there is no %s field.",
+ account.getClass().getSimpleName(),
+ currentFieldName));
+ });
+ }
+ in.endObject();
+ if (log.isDebugEnabled())
+ log.debug("Done de-serializing json.");
+
+ return account;
+ }
+
+ private void invokeSetterMethod(PaymentAccount account, Field field, JsonReader jsonReader) {
+ Optional setter = fieldSettersMap.get(field);
+ if (setter.isPresent()) {
+ try {
+ // The setter might be on the PaymentAccount instance, or its
+ // PaymentAccountPayload instance.
+ if (isSetterOnPaymentAccountClass(setter.get(), account)) {
+ setter.get().invoke(account, nextStringOrNull(jsonReader));
+ } else if (isSetterOnPaymentAccountPayloadClass(setter.get(), account)) {
+ setter.get().invoke(account.getPaymentAccountPayload(), nextStringOrNull(jsonReader));
+ } else {
+ String errMsg = format("programmer error: cannot de-serialize json to a '%s' using reflection"
+ + " because the setter method's declaring class was not found.",
+ account.getClass().getSimpleName());
+ throw new IllegalStateException(errMsg);
+ }
+ } catch (IllegalAccessException | InvocationTargetException ex) {
+ String errMsg = format("cannot set field value for %s on %s",
+ field.getName(),
+ account.getClass().getSimpleName());
+ log.error(StringUtils.capitalize(errMsg) + ".", ex);
+ throw new IllegalStateException("programmer error: " + errMsg);
+ }
+ } else {
+ throw new IllegalStateException(
+ format("programmer error: cannot de-serialize json to a '%s' "
+ + " because there is no setter method for field %s.",
+ account.getClass().getSimpleName(),
+ field.getName()));
+ }
+ }
+
+ private boolean isSetterOnPaymentAccountClass(Method setter, PaymentAccount account) {
+ return isSetterOnClass(setter, account.getClass());
+ }
+
+ private boolean isSetterOnPaymentAccountPayloadClass(Method setter, PaymentAccount account) {
+ return isSetterOnClass(setter, account.getPaymentAccountPayload().getClass())
+ || isSetterOnClass(setter, account.getPaymentAccountPayload().getClass().getSuperclass());
+ }
+
+ private Map> getFieldSetterMap() {
+ List orderedFields = getOrderedFields();
+ Map> map = new LinkedHashMap<>();
+ for (Field field : orderedFields) {
+ Optional setter = getSetterMethodForFieldInClassHierarchy(field, paymentAccountType)
+ .or(() -> getSetterMethodForFieldInClassHierarchy(field, paymentAccountPayloadType));
+ map.put(field, setter);
+ }
+ return Collections.unmodifiableMap(map);
+ }
+
+ private List getOrderedFields() {
+ List fields = new ArrayList<>();
+ loadFieldListForClassHierarchy(fields, paymentAccountType, isExcludedField);
+ loadFieldListForClassHierarchy(fields, paymentAccountPayloadType, isExcludedField);
+ fields.sort(comparing(Field::getName));
+ return fields;
+ }
+
+ private String nextStringOrNull(JsonReader in) {
+ try {
+ if (in.peek() == JsonToken.NULL) {
+ in.nextNull();
+ return null;
+ } else {
+ return in.nextString();
+ }
+ } catch (IOException ex) {
+ String errMsg = "cannot see next string in json reader";
+ log.error(StringUtils.capitalize(errMsg) + ".", ex);
+ throw new IllegalStateException("programmer error: " + errMsg);
+ }
+ }
+
+ @SuppressWarnings("unused")
+ private Long nextLongOrNull(JsonReader in) {
+ try {
+ if (in.peek() == JsonToken.NULL) {
+ in.nextNull();
+ return null;
+ } else {
+ return in.nextLong();
+ }
+ } catch (IOException ex) {
+ String errMsg = "cannot see next long in json reader";
+ log.error(StringUtils.capitalize(errMsg) + ".", ex);
+ throw new IllegalStateException("programmer error: " + errMsg);
+ }
+ }
+
+ private void writeCommonFields(JsonWriter out, PaymentAccount account) throws IOException {
+ if (log.isDebugEnabled())
+ log.debug("writeCommonFields(out, {}) -> paymentMethodId = {}",
+ account, account.getPaymentMethod().getId());
+
+ out.name("_COMMENT_");
+ out.value("Please do not edit the paymentMethodId field.");
+
+ out.name("paymentMethodId");
+ out.value(account.getPaymentMethod().getId());
+ }
+
+ private boolean didReadCommonField(JsonReader in, PaymentAccount account, String fieldName) {
+ switch (fieldName) {
+ case "_COMMENT_":
+ case "paymentMethodId":
+ // skip
+ nextStringOrNull(in);
+ return true;
+ case "accountName":
+ account.setAccountName(nextStringOrNull(in));
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ private boolean didReadCountryField(JsonReader in, PaymentAccount account, String fieldName) {
+ if (account.isCountryBasedPaymentAccount() && fieldName.equals("country")) {
+ // Read the country code, and use it to set the account's country and single
+ // trade currency fields.
+ String countryCode = nextStringOrNull(in);
+ Optional country = findCountryByCode(countryCode);
+ if (country.isPresent()) {
+ ((CountryBasedPaymentAccount) account).setCountry(country.get());
+ FiatCurrency fiatCurrency = getCurrencyByCountryCode(checkNotNull(countryCode));
+ account.setSingleTradeCurrency(fiatCurrency);
+ return true;
+ } else {
+ throw new IllegalArgumentException(
+ format("'%s' is an invalid country code.", countryCode));
+ }
+ } else {
+ return false;
+ }
+ }
+
+ private Class getPaymentAccountPayloadType() {
+ try {
+ Package pkg = PaymentAccountPayload.class.getPackage();
+ //noinspection unchecked
+ return (Class) Class.forName(pkg.getName()
+ + "." + paymentAccountType.getSimpleName() + "Payload");
+ } catch (Exception ex) {
+ String errMsg = format("cannot get the payload class for %s",
+ paymentAccountType.getSimpleName());
+ log.error(StringUtils.capitalize(errMsg) + ".", ex);
+ throw new IllegalStateException("programmer error: " + errMsg);
+
+ }
+ }
+
+ private PaymentAccount initNewPaymentAccount() {
+ try {
+ Constructor constructor = paymentAccountType.getDeclaredConstructor();
+ PaymentAccount paymentAccount = (PaymentAccount) constructor.newInstance();
+ paymentAccount.init();
+ return paymentAccount;
+ } catch (NoSuchMethodException
+ | IllegalAccessException
+ | InstantiationException
+ | InvocationTargetException ex) {
+ String errMsg = format("cannot instantiate a new %s",
+ paymentAccountType.getSimpleName());
+ log.error(StringUtils.capitalize(errMsg) + ".", ex);
+ throw new IllegalStateException("programmer error: " + errMsg);
+ }
+ }
+}
diff --git a/core/src/main/java/bisq/core/btc/model/BsqTransferModel.java b/core/src/main/java/bisq/core/btc/model/BsqTransferModel.java
new file mode 100644
index 00000000000..38e4c4b5423
--- /dev/null
+++ b/core/src/main/java/bisq/core/btc/model/BsqTransferModel.java
@@ -0,0 +1,77 @@
+package bisq.core.btc.model;
+
+import bisq.core.dao.state.model.blockchain.TxType;
+import bisq.core.util.coin.CoinUtil;
+
+import org.bitcoinj.core.Coin;
+import org.bitcoinj.core.LegacyAddress;
+import org.bitcoinj.core.Transaction;
+
+import lombok.Getter;
+
+@Getter
+public final class BsqTransferModel {
+
+ private final LegacyAddress receiverAddress;
+ private final Coin receiverAmount;
+ private final Transaction preparedSendTx;
+ private final Transaction txWithBtcFee;
+ private final Transaction signedTx;
+ private final Coin miningFee;
+ private final int txSize;
+ private final TxType txType;
+
+ public BsqTransferModel(LegacyAddress receiverAddress,
+ Coin receiverAmount,
+ Transaction preparedSendTx,
+ Transaction txWithBtcFee,
+ Transaction signedTx) {
+ this.receiverAddress = receiverAddress;
+ this.receiverAmount = receiverAmount;
+ this.preparedSendTx = preparedSendTx;
+ this.txWithBtcFee = txWithBtcFee;
+ this.signedTx = signedTx;
+ this.miningFee = signedTx.getFee();
+ this.txSize = signedTx.bitcoinSerialize().length;
+ this.txType = TxType.TRANSFER_BSQ;
+ }
+
+ public String getReceiverAddressAsString() {
+ return receiverAddress.toString();
+ }
+
+ public double getMiningFeeInSatoshisPerByte() {
+ return CoinUtil.getFeePerVbyte(miningFee, txSize);
+ }
+
+ public double getTxSizeInKb() {
+ return txSize / 1000d;
+ }
+
+ public String toShortString() {
+ return "{" + "\n" +
+ " receiverAddress='" + getReceiverAddressAsString() + '\'' + "\n" +
+ ", receiverAmount=" + receiverAmount + "\n" +
+ ", txWithBtcFee.txId=" + txWithBtcFee.getTxId() + "\n" +
+ ", miningFee=" + miningFee + "\n" +
+ ", miningFeeInSatoshisPerByte=" + getMiningFeeInSatoshisPerByte() + "\n" +
+ ", txSizeInKb=" + getTxSizeInKb() + "\n" +
+ '}';
+ }
+
+ @Override
+ public String toString() {
+ return "BsqTransferModel{" + "\n" +
+ " receiverAddress='" + getReceiverAddressAsString() + '\'' + "\n" +
+ ", receiverAmount=" + receiverAmount + "\n" +
+ ", preparedSendTx=" + preparedSendTx + "\n" +
+ ", txWithBtcFee=" + txWithBtcFee + "\n" +
+ ", signedTx=" + signedTx + "\n" +
+ ", miningFee=" + miningFee + "\n" +
+ ", miningFeeInSatoshisPerByte=" + getMiningFeeInSatoshisPerByte() + "\n" +
+ ", txSize=" + txSize + "\n" +
+ ", txSizeInKb=" + getTxSizeInKb() + "\n" +
+ ", txType=" + txType + "\n" +
+ '}';
+ }
+}
diff --git a/core/src/main/java/bisq/core/btc/wallet/BsqTransferService.java b/core/src/main/java/bisq/core/btc/wallet/BsqTransferService.java
new file mode 100644
index 00000000000..b6cc83e8c77
--- /dev/null
+++ b/core/src/main/java/bisq/core/btc/wallet/BsqTransferService.java
@@ -0,0 +1,59 @@
+package bisq.core.btc.wallet;
+
+import bisq.core.btc.exceptions.BsqChangeBelowDustException;
+import bisq.core.btc.exceptions.TransactionVerificationException;
+import bisq.core.btc.exceptions.WalletException;
+import bisq.core.btc.model.BsqTransferModel;
+
+import org.bitcoinj.core.Coin;
+import org.bitcoinj.core.InsufficientMoneyException;
+import org.bitcoinj.core.LegacyAddress;
+import org.bitcoinj.core.Transaction;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@Singleton
+public class BsqTransferService {
+
+ private final WalletsManager walletsManager;
+ private final BsqWalletService bsqWalletService;
+ private final BtcWalletService btcWalletService;
+
+ @Inject
+ public BsqTransferService(WalletsManager walletsManager,
+ BsqWalletService bsqWalletService,
+ BtcWalletService btcWalletService) {
+ this.walletsManager = walletsManager;
+ this.bsqWalletService = bsqWalletService;
+ this.btcWalletService = btcWalletService;
+ }
+
+ public BsqTransferModel getBsqTransferModel(LegacyAddress address,
+ Coin receiverAmount)
+ throws TransactionVerificationException,
+ WalletException,
+ BsqChangeBelowDustException,
+ InsufficientMoneyException {
+
+ Transaction preparedSendTx = bsqWalletService.getPreparedSendBsqTx(address.toString(), receiverAmount);
+ Transaction txWithBtcFee = btcWalletService.completePreparedSendBsqTx(preparedSendTx, true);
+ Transaction signedTx = bsqWalletService.signTx(txWithBtcFee);
+
+ return new BsqTransferModel(address,
+ receiverAmount,
+ preparedSendTx,
+ txWithBtcFee,
+ signedTx);
+ }
+
+ public void sendFunds(BsqTransferModel bsqTransferModel, TxBroadcaster.Callback callback) {
+ log.info("Publishing BSQ transfer {}", bsqTransferModel.toShortString());
+ walletsManager.publishAndCommitBsqTx(bsqTransferModel.getTxWithBtcFee(),
+ bsqTransferModel.getTxType(),
+ callback);
+ }
+}
diff --git a/core/src/main/java/bisq/core/offer/OfferUtil.java b/core/src/main/java/bisq/core/offer/OfferUtil.java
index e85881c2112..50fd938d6e9 100644
--- a/core/src/main/java/bisq/core/offer/OfferUtil.java
+++ b/core/src/main/java/bisq/core/offer/OfferUtil.java
@@ -49,6 +49,7 @@
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
+import java.util.function.Predicate;
import lombok.extern.slf4j.Slf4j;
@@ -63,6 +64,7 @@
import static bisq.core.offer.OfferPayload.*;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
+import static java.lang.String.format;
/**
* This class holds utility methods for creating, editing and taking an Offer.
@@ -79,6 +81,9 @@ public class OfferUtil {
private final P2PService p2PService;
private final ReferralIdService referralIdService;
+ private final Predicate isValidFeePaymentCurrencyCode = (c) ->
+ c.equalsIgnoreCase("BSQ") || c.equalsIgnoreCase("BTC");
+
@Inject
public OfferUtil(AccountAgeWitnessService accountAgeWitnessService,
BsqWalletService bsqWalletService,
@@ -96,6 +101,19 @@ public OfferUtil(AccountAgeWitnessService accountAgeWitnessService,
this.referralIdService = referralIdService;
}
+ public void maybeSetFeePaymentCurrencyPreference(String feeCurrencyCode) {
+ if (!feeCurrencyCode.isEmpty()) {
+ if (!isValidFeePaymentCurrencyCode.test(feeCurrencyCode))
+ throw new IllegalStateException(format("%s cannot be used to pay trade fees",
+ feeCurrencyCode.toUpperCase()));
+
+ if (feeCurrencyCode.equalsIgnoreCase("BSQ") && preferences.isPayFeeInBtc())
+ preferences.setPayFeeInBtc(false);
+ else if (feeCurrencyCode.equalsIgnoreCase("BTC") && !preferences.isPayFeeInBtc())
+ preferences.setPayFeeInBtc(true);
+ }
+ }
+
/**
* Given the direction, is this a BUY?
*
diff --git a/core/src/main/java/bisq/core/payment/PaymentAccount.java b/core/src/main/java/bisq/core/payment/PaymentAccount.java
index b38649ef942..f94811585f1 100644
--- a/core/src/main/java/bisq/core/payment/PaymentAccount.java
+++ b/core/src/main/java/bisq/core/payment/PaymentAccount.java
@@ -173,6 +173,10 @@ public String getOwnerId() {
return paymentAccountPayload.getOwnerId();
}
+ public boolean isCountryBasedPaymentAccount() {
+ return this instanceof CountryBasedPaymentAccount;
+ }
+
public boolean isHalCashAccount() {
return this instanceof HalCashAccount;
}
diff --git a/daemon/src/main/java/bisq/daemon/grpc/GrpcOffersService.java b/daemon/src/main/java/bisq/daemon/grpc/GrpcOffersService.java
index f03155d2f8d..1efed108ca6 100644
--- a/daemon/src/main/java/bisq/daemon/grpc/GrpcOffersService.java
+++ b/daemon/src/main/java/bisq/daemon/grpc/GrpcOffersService.java
@@ -100,6 +100,7 @@ public void createOffer(CreateOfferRequest req,
req.getMinAmount(),
req.getBuyerSecurityDeposit(),
req.getPaymentAccountId(),
+ req.getMakerFeeCurrencyCode(),
offer -> {
// This result handling consumer's accept operation will return
// the new offer to the gRPC client after async placement is done.
diff --git a/daemon/src/main/java/bisq/daemon/grpc/GrpcPaymentAccountsService.java b/daemon/src/main/java/bisq/daemon/grpc/GrpcPaymentAccountsService.java
index 91060cbc829..0438d33655d 100644
--- a/daemon/src/main/java/bisq/daemon/grpc/GrpcPaymentAccountsService.java
+++ b/daemon/src/main/java/bisq/daemon/grpc/GrpcPaymentAccountsService.java
@@ -19,13 +19,20 @@
import bisq.core.api.CoreApi;
import bisq.core.payment.PaymentAccount;
+import bisq.core.payment.payload.PaymentMethod;
import bisq.proto.grpc.CreatePaymentAccountReply;
import bisq.proto.grpc.CreatePaymentAccountRequest;
+import bisq.proto.grpc.GetPaymentAccountFormReply;
+import bisq.proto.grpc.GetPaymentAccountFormRequest;
import bisq.proto.grpc.GetPaymentAccountsReply;
import bisq.proto.grpc.GetPaymentAccountsRequest;
+import bisq.proto.grpc.GetPaymentMethodsReply;
+import bisq.proto.grpc.GetPaymentMethodsRequest;
import bisq.proto.grpc.PaymentAccountsGrpc;
+import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
import io.grpc.stub.StreamObserver;
import javax.inject.Inject;
@@ -45,24 +52,86 @@ public GrpcPaymentAccountsService(CoreApi coreApi) {
@Override
public void createPaymentAccount(CreatePaymentAccountRequest req,
StreamObserver responseObserver) {
- coreApi.createPaymentAccount(req.getPaymentMethodId(),
- req.getAccountName(),
- req.getAccountNumber(),
- req.getCurrencyCode());
- var reply = CreatePaymentAccountReply.newBuilder().build();
- responseObserver.onNext(reply);
- responseObserver.onCompleted();
+ try {
+ PaymentAccount paymentAccount = coreApi.createPaymentAccount(req.getPaymentAccountForm());
+ var reply = CreatePaymentAccountReply.newBuilder()
+ .setPaymentAccount(paymentAccount.toProtoMessage())
+ .build();
+ responseObserver.onNext(reply);
+ responseObserver.onCompleted();
+ } catch (IllegalArgumentException cause) {
+ var ex = new StatusRuntimeException(Status.INVALID_ARGUMENT.withDescription(cause.getMessage()));
+ responseObserver.onError(ex);
+ throw ex;
+ } catch (IllegalStateException cause) {
+ var ex = new StatusRuntimeException(Status.UNKNOWN.withDescription(cause.getMessage()));
+ responseObserver.onError(ex);
+ throw ex;
+ }
}
@Override
public void getPaymentAccounts(GetPaymentAccountsRequest req,
StreamObserver responseObserver) {
- var paymentAccounts = coreApi.getPaymentAccounts().stream()
- .map(PaymentAccount::toProtoMessage)
- .collect(Collectors.toList());
- var reply = GetPaymentAccountsReply.newBuilder()
- .addAllPaymentAccounts(paymentAccounts).build();
- responseObserver.onNext(reply);
- responseObserver.onCompleted();
+ try {
+ var paymentAccounts = coreApi.getPaymentAccounts().stream()
+ .map(PaymentAccount::toProtoMessage)
+ .collect(Collectors.toList());
+ var reply = GetPaymentAccountsReply.newBuilder()
+ .addAllPaymentAccounts(paymentAccounts).build();
+ responseObserver.onNext(reply);
+ responseObserver.onCompleted();
+ } catch (IllegalArgumentException cause) {
+ var ex = new StatusRuntimeException(Status.INVALID_ARGUMENT.withDescription(cause.getMessage()));
+ responseObserver.onError(ex);
+ throw ex;
+ } catch (IllegalStateException cause) {
+ var ex = new StatusRuntimeException(Status.UNKNOWN.withDescription(cause.getMessage()));
+ responseObserver.onError(ex);
+ throw ex;
+ }
+ }
+
+ @Override
+ public void getPaymentMethods(GetPaymentMethodsRequest req,
+ StreamObserver responseObserver) {
+ try {
+ var paymentMethods = coreApi.getFiatPaymentMethods().stream()
+ .map(PaymentMethod::toProtoMessage)
+ .collect(Collectors.toList());
+ var reply = GetPaymentMethodsReply.newBuilder()
+ .addAllPaymentMethods(paymentMethods).build();
+ responseObserver.onNext(reply);
+ responseObserver.onCompleted();
+ } catch (IllegalArgumentException cause) {
+ var ex = new StatusRuntimeException(Status.INVALID_ARGUMENT.withDescription(cause.getMessage()));
+ responseObserver.onError(ex);
+ throw ex;
+ } catch (IllegalStateException cause) {
+ var ex = new StatusRuntimeException(Status.UNKNOWN.withDescription(cause.getMessage()));
+ responseObserver.onError(ex);
+ throw ex;
+ }
+ }
+
+ @Override
+ public void getPaymentAccountForm(GetPaymentAccountFormRequest req,
+ StreamObserver responseObserver) {
+ try {
+ var paymentAccountFormJson = coreApi.getPaymentAccountForm(req.getPaymentMethodId());
+ var reply = GetPaymentAccountFormReply.newBuilder()
+ .setPaymentAccountFormJson(paymentAccountFormJson)
+ .build();
+ responseObserver.onNext(reply);
+ responseObserver.onCompleted();
+ } catch (IllegalArgumentException cause) {
+ var ex = new StatusRuntimeException(Status.INVALID_ARGUMENT.withDescription(cause.getMessage()));
+ responseObserver.onError(ex);
+ throw ex;
+ } catch (IllegalStateException cause) {
+ var ex = new StatusRuntimeException(Status.UNKNOWN.withDescription(cause.getMessage()));
+ responseObserver.onError(ex);
+ throw ex;
+ }
}
}
diff --git a/daemon/src/main/java/bisq/daemon/grpc/GrpcTradesService.java b/daemon/src/main/java/bisq/daemon/grpc/GrpcTradesService.java
index 74cd04ead93..449859a9f63 100644
--- a/daemon/src/main/java/bisq/daemon/grpc/GrpcTradesService.java
+++ b/daemon/src/main/java/bisq/daemon/grpc/GrpcTradesService.java
@@ -79,6 +79,7 @@ public void takeOffer(TakeOfferRequest req,
try {
coreApi.takeOffer(req.getOfferId(),
req.getPaymentAccountId(),
+ req.getTakerFeeCurrencyCode(),
trade -> {
TradeInfo tradeInfo = toTradeInfo(trade);
var reply = TakeOfferReply.newBuilder()
diff --git a/daemon/src/main/java/bisq/daemon/grpc/GrpcWalletsService.java b/daemon/src/main/java/bisq/daemon/grpc/GrpcWalletsService.java
index 1b5cb42e4cc..110e4b5cc65 100644
--- a/daemon/src/main/java/bisq/daemon/grpc/GrpcWalletsService.java
+++ b/daemon/src/main/java/bisq/daemon/grpc/GrpcWalletsService.java
@@ -19,17 +19,23 @@
import bisq.core.api.CoreApi;
import bisq.core.api.model.AddressBalanceInfo;
+import bisq.core.btc.exceptions.TxBroadcastException;
+import bisq.core.btc.wallet.TxBroadcaster;
import bisq.proto.grpc.GetAddressBalanceReply;
import bisq.proto.grpc.GetAddressBalanceRequest;
-import bisq.proto.grpc.GetBalanceReply;
-import bisq.proto.grpc.GetBalanceRequest;
+import bisq.proto.grpc.GetBalancesReply;
+import bisq.proto.grpc.GetBalancesRequest;
import bisq.proto.grpc.GetFundingAddressesReply;
import bisq.proto.grpc.GetFundingAddressesRequest;
+import bisq.proto.grpc.GetUnusedBsqAddressReply;
+import bisq.proto.grpc.GetUnusedBsqAddressRequest;
import bisq.proto.grpc.LockWalletReply;
import bisq.proto.grpc.LockWalletRequest;
import bisq.proto.grpc.RemoveWalletPasswordReply;
import bisq.proto.grpc.RemoveWalletPasswordRequest;
+import bisq.proto.grpc.SendBsqReply;
+import bisq.proto.grpc.SendBsqRequest;
import bisq.proto.grpc.SetWalletPasswordReply;
import bisq.proto.grpc.SetWalletPasswordRequest;
import bisq.proto.grpc.UnlockWalletReply;
@@ -40,11 +46,16 @@
import io.grpc.StatusRuntimeException;
import io.grpc.stub.StreamObserver;
+import org.bitcoinj.core.Transaction;
+
import javax.inject.Inject;
import java.util.List;
import java.util.stream.Collectors;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
class GrpcWalletsService extends WalletsGrpc.WalletsImplBase {
private final CoreApi coreApi;
@@ -54,17 +65,13 @@ public GrpcWalletsService(CoreApi coreApi) {
this.coreApi = coreApi;
}
- // TODO we need to support 3 or 4 balance types: available, reserved, lockedInTrade
- // and maybe total wallet balance (available+reserved). To not duplicate the methods,
- // we should pass an enum type. Enums in proto are a bit cumbersome as they are
- // global so you quickly run into namespace conflicts if not always prefixes which
- // makes it more verbose. In the core code base we move to the strategy to store the
- // enum name and map it. This gives also more flexibility with updates.
@Override
- public void getBalance(GetBalanceRequest req, StreamObserver responseObserver) {
+ public void getBalances(GetBalancesRequest req, StreamObserver responseObserver) {
try {
- long availableBalance = coreApi.getAvailableBalance();
- var reply = GetBalanceReply.newBuilder().setBalance(availableBalance).build();
+ var balances = coreApi.getBalances(req.getCurrencyCode());
+ var reply = GetBalancesReply.newBuilder()
+ .setBalances(balances.toProtoMessage())
+ .build();
responseObserver.onNext(reply);
responseObserver.onCompleted();
} catch (IllegalStateException cause) {
@@ -110,6 +117,52 @@ public void getFundingAddresses(GetFundingAddressesRequest req,
}
}
+ @Override
+ public void getUnusedBsqAddress(GetUnusedBsqAddressRequest req,
+ StreamObserver responseObserver) {
+ try {
+ String address = coreApi.getUnusedBsqAddress();
+ var reply = GetUnusedBsqAddressReply.newBuilder()
+ .setAddress(address)
+ .build();
+ responseObserver.onNext(reply);
+ responseObserver.onCompleted();
+ } catch (IllegalStateException cause) {
+ var ex = new StatusRuntimeException(Status.UNKNOWN.withDescription(cause.getMessage()));
+ responseObserver.onError(ex);
+ throw ex;
+ }
+ }
+
+ @Override
+ public void sendBsq(SendBsqRequest req,
+ StreamObserver responseObserver) {
+ try {
+ coreApi.sendBsq(req.getAddress(), req.getAmount(), new TxBroadcaster.Callback() {
+ @Override
+ public void onSuccess(Transaction tx) {
+ log.info("Successfully published BSQ tx: id {}, output sum {} sats, fee {} sats, size {} bytes",
+ tx.getTxId().toString(),
+ tx.getOutputSum(),
+ tx.getFee(),
+ tx.getMessageSize());
+ var reply = SendBsqReply.newBuilder().build();
+ responseObserver.onNext(reply);
+ responseObserver.onCompleted();
+ }
+
+ @Override
+ public void onFailure(TxBroadcastException ex) {
+ throw new IllegalStateException(ex);
+ }
+ });
+ } catch (IllegalStateException cause) {
+ var ex = new StatusRuntimeException(Status.UNKNOWN.withDescription(cause.getMessage()));
+ responseObserver.onError(ex);
+ throw ex;
+ }
+ }
+
@Override
public void setWalletPassword(SetWalletPasswordRequest req,
StreamObserver responseObserver) {
diff --git a/proto/src/main/proto/grpc.proto b/proto/src/main/proto/grpc.proto
index d9e0a3973d8..b20a508ddea 100644
--- a/proto/src/main/proto/grpc.proto
+++ b/proto/src/main/proto/grpc.proto
@@ -81,6 +81,7 @@ message CreateOfferRequest {
uint64 minAmount = 7;
double buyerSecurityDeposit = 8;
string paymentAccountId = 9;
+ string makerFeeCurrencyCode = 10;
}
message CreateOfferReply {
@@ -105,13 +106,14 @@ message OfferInfo {
uint64 volume = 8;
uint64 minVolume = 9;
uint64 buyerSecurityDeposit = 10;
- string paymentAccountId = 11;
- string paymentMethodId = 12;
- string paymentMethodShortName = 13;
- string baseCurrencyCode = 14;
- string counterCurrencyCode = 15;
- uint64 date = 16;
- string state = 17;
+ bool isCurrencyForMakerFeeBtc = 11;
+ string paymentAccountId = 12;
+ string paymentMethodId = 13;
+ string paymentMethodShortName = 14;
+ string baseCurrencyCode = 15;
+ string counterCurrencyCode = 16;
+ uint64 date = 17;
+ string state = 18;
}
///////////////////////////////////////////////////////////////////////////////////////////
@@ -123,17 +125,18 @@ service PaymentAccounts {
}
rpc GetPaymentAccounts (GetPaymentAccountsRequest) returns (GetPaymentAccountsReply) {
}
+ rpc GetPaymentMethods (GetPaymentMethodsRequest) returns (GetPaymentMethodsReply) {
+ }
+ rpc GetPaymentAccountForm (GetPaymentAccountFormRequest) returns (GetPaymentAccountFormReply) {
+ }
}
message CreatePaymentAccountRequest {
- string paymentMethodId = 1;
- string accountName = 2;
- string accountNumber = 3;
- // TODO Support all currencies. Maybe add a repeated and if only one is used its a singletonList.
- string currencyCode = 4;
+ string paymentAccountForm = 1;
}
message CreatePaymentAccountReply {
+ PaymentAccount paymentAccount = 1;
}
message GetPaymentAccountsRequest {
@@ -143,6 +146,21 @@ message GetPaymentAccountsReply {
repeated PaymentAccount paymentAccounts = 1;
}
+message GetPaymentMethodsRequest {
+}
+
+message GetPaymentMethodsReply {
+ repeated PaymentMethod paymentMethods = 1;
+}
+
+message GetPaymentAccountFormRequest {
+ string paymentMethodId = 1;
+}
+
+message GetPaymentAccountFormReply {
+ string paymentAccountFormJson = 1;
+}
+
///////////////////////////////////////////////////////////////////////////////////////////
// Price
///////////////////////////////////////////////////////////////////////////////////////////
@@ -198,6 +216,7 @@ service Trades {
message TakeOfferRequest {
string offerId = 1;
string paymentAccountId = 2;
+ string takerFeeCurrencyCode = 3;
}
message TakeOfferReply {
@@ -273,10 +292,14 @@ message TradeInfo {
///////////////////////////////////////////////////////////////////////////////////////////
service Wallets {
- rpc GetBalance (GetBalanceRequest) returns (GetBalanceReply) {
+ rpc GetBalances (GetBalancesRequest) returns (GetBalancesReply) {
}
rpc GetAddressBalance (GetAddressBalanceRequest) returns (GetAddressBalanceReply) {
}
+ rpc GetUnusedBsqAddress (GetUnusedBsqAddressRequest) returns (GetUnusedBsqAddressReply) {
+ }
+ rpc SendBsq (SendBsqRequest) returns (SendBsqReply) {
+ }
rpc GetFundingAddresses (GetFundingAddressesRequest) returns (GetFundingAddressesReply) {
}
rpc SetWalletPassword (SetWalletPasswordRequest) returns (SetWalletPasswordReply) {
@@ -289,11 +312,12 @@ service Wallets {
}
}
-message GetBalanceRequest {
+message GetBalancesRequest {
+ string currencyCode = 1;
}
-message GetBalanceReply {
- uint64 balance = 1;
+message GetBalancesReply {
+ BalancesInfo balances = 1;
}
message GetAddressBalanceRequest {
@@ -304,6 +328,21 @@ message GetAddressBalanceReply {
AddressBalanceInfo addressBalanceInfo = 1;
}
+message GetUnusedBsqAddressRequest {
+}
+
+message GetUnusedBsqAddressReply {
+ string address = 1;
+}
+
+message SendBsqRequest {
+ string address = 1;
+ double amount = 2;
+}
+
+message SendBsqReply {
+}
+
message GetFundingAddressesRequest {
}
@@ -340,6 +379,30 @@ message UnlockWalletRequest {
message UnlockWalletReply {
}
+message BalancesInfo {
+ // Field names are shortened for readability's sake, i.e.,
+ // balancesInfo.getBtc().getAvailableBalance() is cleaner than
+ // balancesInfo.getBtcBalanceInfo().getAvailableBalance().
+ BsqBalanceInfo bsq = 1;
+ BtcBalanceInfo btc = 2;
+}
+
+message BsqBalanceInfo {
+ uint64 availableConfirmedBalance = 1;
+ uint64 unverifiedBalance = 2;
+ uint64 unconfirmedChangeBalance = 3;
+ uint64 lockedForVotingBalance = 4;
+ uint64 lockupBondsBalance = 5;
+ uint64 unlockingBondsBalance = 6;
+}
+
+message BtcBalanceInfo {
+ uint64 availableBalance = 1;
+ uint64 reservedBalance = 2;
+ uint64 totalAvailableBalance = 3;
+ uint64 lockedBalance = 4;
+}
+
message AddressBalanceInfo {
string address = 1;
int64 balance = 2;