Bump java-stellar-sdk to v1.0.0

core/build.gradle.kts

@@ -17,6 +17,7 @@ dependencies {
 
   implementation(libs.apache.commons.lang3)
   implementation(libs.bcastle)
+  implementation(libs.bcutil)
   implementation(libs.commons.beanutils)
   implementation(libs.commons.codec)
   implementation(libs.commons.io)

core/src/main/java/org/stellar/anchor/auth/Sep10Jwt.java

@@ -9,9 +9,7 @@
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
-import org.stellar.sdk.AccountConverter;
-import org.stellar.sdk.KeyPair;
-import org.stellar.sdk.xdr.MuxedAccount;
+import org.stellar.sdk.MuxedAccount;
 
 @Getter
 @Setter
@@ -111,13 +109,11 @@ void updateAccountAndMemo() {
         this.accountMemo = null;
 
         try {
-          MuxedAccount maybeMuxedAccount = AccountConverter.enableMuxed().encode(sub);
-          MuxedAccount.MuxedAccountMed25519 muxedAccount = maybeMuxedAccount.getMed25519();
-          if (muxedAccount != null) {
+          MuxedAccount maybeMuxedAccount = new MuxedAccount(sub);
+          if (maybeMuxedAccount.getMuxedId() != null) {
             this.muxedAccount = sub;
-            byte[] pubKeyBytes = muxedAccount.getEd25519().getUint256();
-            this.account = KeyPair.fromPublicKey(pubKeyBytes).getAccountId();
-            this.muxedAccountId = muxedAccount.getId().getUint64().getNumber().longValue();
+            this.account = maybeMuxedAccount.getAccountId();
+            this.muxedAccountId = maybeMuxedAccount.getMuxedId().longValue();
           }
         } catch (Exception ignored) {
         }

core/src/main/java/org/stellar/anchor/horizon/Horizon.java

@@ -2,16 +2,18 @@
 
 import static org.stellar.anchor.api.asset.AssetInfo.NATIVE_ASSET_CODE;
 
-import java.io.IOException;
-import java.util.Arrays;
 import java.util.List;
 import lombok.Getter;
 import org.stellar.anchor.config.AppConfig;
 import org.stellar.anchor.util.AssetHelper;
 import org.stellar.sdk.AssetTypeCreditAlphaNum;
 import org.stellar.sdk.Server;
+import org.stellar.sdk.TrustLineAsset;
+import org.stellar.sdk.exception.NetworkException;
+import org.stellar.sdk.requests.PaymentsRequestBuilder;
 import org.stellar.sdk.responses.AccountResponse;
 import org.stellar.sdk.responses.operations.OperationResponse;
+import org.stellar.sdk.xdr.AssetType;
 
 /** The horizon-server. */
 public class Horizon {
@@ -30,29 +32,38 @@ public Server getServer() {
     return this.horizonServer;
   }
 
-  public boolean isTrustlineConfigured(String account, String asset) throws IOException {
+  public boolean isTrustlineConfigured(String account, String asset) throws NetworkException {
     String assetCode = AssetHelper.getAssetCode(asset);
     if (NATIVE_ASSET_CODE.equals(assetCode)) {
       return true;
     }
     String assetIssuer = AssetHelper.getAssetIssuer(asset);
 
     AccountResponse accountResponse = getServer().accounts().account(account);
-    return Arrays.stream(accountResponse.getBalances())
+    return accountResponse.getBalances().stream()
         .anyMatch(
             balance -> {
-              if (balance.getAssetType().equals("credit_alphanum4")
-                  || balance.getAssetType().equals("credit_alphanum12")) {
+              TrustLineAsset trustLineAsset = balance.getTrustLineAsset();
+              if (trustLineAsset.getAssetType() == AssetType.ASSET_TYPE_CREDIT_ALPHANUM4
+                  || trustLineAsset.getAssetType() == AssetType.ASSET_TYPE_CREDIT_ALPHANUM12) {
                 AssetTypeCreditAlphaNum creditAsset =
-                    (AssetTypeCreditAlphaNum) balance.getAsset().get();
+                    (AssetTypeCreditAlphaNum) trustLineAsset.getAsset();
+                assert creditAsset != null;
                 return creditAsset.getCode().equals(assetCode)
                     && creditAsset.getIssuer().equals(assetIssuer);
               }
               return false;
             });
   }
 
-  public List<OperationResponse> getStellarTxnOperations(String stellarTxnId) throws IOException {
+  /**
+   * Get payment operations for a transaction.
+   *
+   * @param stellarTxnId the transaction id
+   * @return the operations
+   * @throws NetworkException request failed, see {@link PaymentsRequestBuilder#execute()}
+   */
+  public List<OperationResponse> getStellarTxnOperations(String stellarTxnId) {
     return getServer()
         .payments()
         .includeTransactions(true)

core/src/main/java/org/stellar/anchor/sep10/Sep10Helper.java

@@ -10,7 +10,6 @@
 import org.stellar.anchor.api.exception.InvalidConfigException;
 import org.stellar.anchor.api.exception.SepException;
 import org.stellar.anchor.util.Sep1Helper;
-import org.stellar.sdk.FormatException;
 import org.stellar.sdk.KeyPair;
 
 public class Sep10Helper {
@@ -39,7 +38,7 @@ public static String fetchSigningKeyFromClientDomain(String clientDomain, boolea
       debugF("Validating client_domain signing key: {}", clientSigningKey);
       KeyPair.fromAccountId(clientSigningKey);
       return clientSigningKey;
-    } catch (IllegalArgumentException | FormatException e) {
+    } catch (IllegalArgumentException e) {
       infoF("SIGNING_KEY {} is not a valid Stellar account Id.", clientSigningKey);
       throw new SepException(
           String.format("SIGNING_KEY %s is not a valid Stellar account Id.", clientSigningKey));

core/src/main/java/org/stellar/anchor/sep10/Sep10Service.java

@@ -11,7 +11,6 @@
 import io.jsonwebtoken.Jws;
 import io.micrometer.core.instrument.Counter;
 import io.micrometer.core.instrument.Metrics;
-import java.io.IOException;
 import java.time.Instant;
 import java.util.Arrays;
 import java.util.HashSet;
@@ -36,7 +35,10 @@
 import org.stellar.anchor.util.Log;
 import org.stellar.sdk.*;
 import org.stellar.sdk.Sep10Challenge.ChallengeTransaction;
-import org.stellar.sdk.requests.ErrorResponse;
+import org.stellar.sdk.exception.InvalidSep10ChallengeException;
+import org.stellar.sdk.exception.NetworkException;
+import org.stellar.sdk.operations.ManageDataOperation;
+import org.stellar.sdk.operations.Operation;
 import org.stellar.sdk.responses.AccountResponse;
 
 /** The Sep-10 protocol service. */
@@ -114,7 +116,7 @@ public ChallengeResponse createChallenge(
   }
 
   public ValidationResponse validateChallenge(ValidationRequest request)
-      throws IOException, InvalidSep10ChallengeException, SepValidationException {
+      throws SepValidationException {
     info("Validating SEP-10 challenge.");
 
     ChallengeTransaction challenge = parseChallenge(request);
@@ -176,8 +178,7 @@ public ChallengeResponse createChallengeResponse(
     }
   }
 
-  Transaction newChallenge(ChallengeRequest request, String clientSigningKey, Memo memo)
-      throws InvalidSep10ChallengeException {
+  Transaction newChallenge(ChallengeRequest request, String clientSigningKey, Memo memo) {
 
     KeyPair signer = KeyPair.fromSecretSeed(secretConfig.getSep10SigningSeed());
     long now = Instant.now().getEpochSecond();
@@ -380,15 +381,15 @@ void validateAccountFormat(ChallengeRequest request) throws SepException {
     // Validate account
     try {
       KeyPair.fromAccountId(request.getAccount());
-    } catch (Exception ex) {
+    } catch (IllegalArgumentException ex) {
       infoF("client wallet account ({}) is invalid", request.getAccount());
       throw new SepValidationException("Invalid account.");
     }
   }
 
   void validateChallengeRequest(
       ValidationRequest request, AccountResponse account, String clientDomain)
-      throws InvalidSep10ChallengeException, IOException, SepValidationException {
+      throws SepValidationException {
     // fetch the signers from the transaction
     Set<Sep10Challenge.Signer> signers = fetchSigners(account);
     // the signatures must be greater than the medium threshold of the account.
@@ -415,15 +416,15 @@ void validateChallengeRequest(
 
   Set<Sep10Challenge.Signer> fetchSigners(AccountResponse account) {
     // Find the signers of the client account.
-    return Arrays.stream(account.getSigners())
+    return account.getSigners().stream()
         .filter(as -> as.getType().equals("ed25519_public_key"))
         .map(as -> new Sep10Challenge.Signer(as.getKey(), as.getWeight()))
         .collect(Collectors.toSet());
   }
 
   AccountResponse fetchAccount(
       ValidationRequest request, ChallengeTransaction challenge, String clientDomain)
-      throws InvalidSep10ChallengeException, IOException, SepValidationException {
+      throws SepValidationException {
     // Check the client's account
     AccountResponse account;
     try {
@@ -432,7 +433,7 @@ AccountResponse fetchAccount(
       traceF("challenge account: {}", account);
       sep10ChallengeValidatedCounter.increment();
       return account;
-    } catch (ErrorResponse | IOException ex) {
+    } catch (NetworkException ex) {
       infoF("Account {} does not exist in the Stellar Network");
       // account not found
       // The client account does not exist, using the client's master key to verify.
@@ -494,8 +495,7 @@ String fetchClientDomain(ChallengeTransaction challenge) {
     return clientDomain;
   }
 
-  ChallengeTransaction parseChallenge(ValidationRequest request)
-      throws IOException, InvalidSep10ChallengeException, SepValidationException {
+  ChallengeTransaction parseChallenge(ValidationRequest request) throws SepValidationException {
 
     if (request == null || request.getTransaction() == null) {
       throw new SepValidationException("{transaction} is required.");
@@ -554,13 +554,17 @@ private String authUrl() {
    * @param network The network to connect to for verifying and retrieving.
    * @return The extracted home domain from the Manage Data operation within the SEP-10 challenge
    *     transaction.
-   * @throws IOException If read XDR string fails, the exception will be thrown.
    * @throws SepValidationException If the transaction is not a valid SEP-10 challenge transaction.
    */
   String extractHomeDomainFromChallengeXdr(String challengeXdr, Network network)
-      throws IOException, SepValidationException {
-    AbstractTransaction parsed =
-        Transaction.fromEnvelopeXdr(AccountConverter.enableMuxed(), challengeXdr, network);
+      throws SepValidationException {
+    AbstractTransaction parsed;
+    try {
+      parsed = Transaction.fromEnvelopeXdr(challengeXdr, network);
+    } catch (IllegalArgumentException e) {
+      throw new SepValidationException("Invalid challenge transaction.");
+    }
+
     if (!(parsed instanceof Transaction)) {
       throw new SepValidationException("Transaction cannot be a fee bump transaction");
     }
@@ -603,8 +607,7 @@ public synchronized Transaction newChallenge(
       TimeBounds timebounds,
       String clientDomain,
       String clientSigningKey,
-      Memo memo)
-      throws InvalidSep10ChallengeException {
+      Memo memo) {
     return Sep10Challenge.newChallenge(
         signer,
         network,
@@ -622,8 +625,7 @@ public synchronized ChallengeTransaction readChallengeTransaction(
       String serverAccountId,
       Network network,
       String domainName,
-      String webAuthDomain)
-      throws InvalidSep10ChallengeException, IOException {
+      String webAuthDomain) {
     return Sep10Challenge.readChallengeTransaction(
         challengeXdr, serverAccountId, network, domainName, webAuthDomain);
   }
@@ -634,8 +636,7 @@ public synchronized void verifyChallengeTransactionSigners(
       Network network,
       String domainName,
       String webAuthDomain,
-      Set<String> signers)
-      throws InvalidSep10ChallengeException, IOException {
+      Set<String> signers) {
     Sep10Challenge.verifyChallengeTransactionSigners(
         challengeXdr, serverAccountId, network, domainName, webAuthDomain, signers);
   }
@@ -647,8 +648,7 @@ public synchronized void verifyChallengeTransactionThreshold(
       String domainName,
       String webAuthDomain,
       int threshold,
-      Set<Sep10Challenge.Signer> signers)
-      throws InvalidSep10ChallengeException, IOException {
+      Set<Sep10Challenge.Signer> signers) {
     Sep10Challenge.verifyChallengeTransactionThreshold(
         challengeXdr, serverAccountId, network, domainName, webAuthDomain, threshold, signers);
   }

core/src/main/java/org/stellar/anchor/sep24/Sep24Service.java

@@ -188,7 +188,7 @@ public InteractiveTransactionResponse withdraw(
     try {
       debugF("checking if withdraw source account:{} is valid", sourceAccount);
       KeyPair.fromAccountId(sourceAccount);
-    } catch (Exception ex) {
+    } catch (IllegalArgumentException ex) {
       infoF("invalid account format: {}", sourceAccount);
       throw new SepValidationException(String.format("invalid account: %s", sourceAccount), ex);
     }
@@ -382,7 +382,7 @@ public InteractiveTransactionResponse deposit(Sep10Jwt token, Map<String, String
     try {
       debugF("checking if deposit destination account:{} is valid", destinationAccount);
       KeyPair.fromAccountId(destinationAccount);
-    } catch (Exception ex) {
+    } catch (IllegalArgumentException ex) {
       infoF("invalid account format: {}", destinationAccount);
       throw new SepValidationException(
           String.format("invalid account: %s", destinationAccount), ex);

core/src/main/java/org/stellar/anchor/sep6/RequestValidator.java

@@ -108,7 +108,7 @@ public void validateTypes(String requestType, String assetCode, List<String> val
   public void validateAccount(String account) throws AnchorException {
     try {
       KeyPair.fromAccountId(account);
-    } catch (RuntimeException ex) {
+    } catch (IllegalArgumentException ex) {
       throw new SepValidationException(String.format("invalid account %s", account));
     }
   }

core/src/main/java/org/stellar/anchor/util/AssetHelper.java

@@ -37,7 +37,7 @@ public static boolean isNonNativeAsset(String assetCode, String assetIssuer) {
     try {
       KeyPair.fromAccountId(assetIssuer);
       return true;
-    } catch (Exception ex) {
+    } catch (IllegalArgumentException ex) {
       return false;
     }
   }

core/src/main/java/org/stellar/anchor/util/SepHelper.java

@@ -11,9 +11,9 @@
 import org.stellar.anchor.api.exception.BadRequestException;
 import org.stellar.anchor.api.exception.InvalidStellarAccountException;
 import org.stellar.anchor.api.sep.SepTransactionStatus;
-import org.stellar.sdk.AccountConverter;
 import org.stellar.sdk.KeyPair;
-import org.stellar.sdk.xdr.*;
+import org.stellar.sdk.MuxedAccount;
+import org.stellar.sdk.xdr.MemoType;
 
 public class SepHelper {
   /**
@@ -59,15 +59,11 @@ public static String memoTypeString(MemoType memoType) {
   public static String getAccountMemo(String strAccount) throws InvalidStellarAccountException {
     String[] tokens = strAccount.split(":");
     switch (tokens.length) {
+        // TODO: Should we add a catch here to throw an InvalidStellarAccountException exception in
+        // case of invalid address?
       case 1:
-        AccountConverter accountConverter;
-        if (tokens[0].startsWith("G")) {
-          accountConverter = AccountConverter.disableMuxed();
-        } else {
-          accountConverter = AccountConverter.enableMuxed();
-        }
         // Check if the account is a valid G... or M...
-        accountConverter.encode(tokens[0]);
+        new MuxedAccount(tokens[0]);
         return null;
       case 2:
         KeyPair.fromAccountId(tokens[0]);