Implement GetBalance client call and server endpoint

httpclient/src/main/kotlin/tbdex/sdk/httpclient/RequestToken.kt

@@ -44,7 +44,6 @@ object RequestToken {
         .didDocument?.findAssertionMethodById(assertionMethodId)
         ?: throw RequestTokenCreateException("Assertion method not found")
 
-    // TODO: ensure that publicKeyJwk is not null
     val publicKeyJwk = assertionMethod.publicKeyJwk
     check(publicKeyJwk != null) { "publicKeyJwk is null" }
     val keyAlias = did.keyManager.getDeterministicAlias(publicKeyJwk)

httpclient/src/main/kotlin/tbdex/sdk/httpclient/TbdexHttpClient.kt

@@ -15,6 +15,7 @@ import tbdex.sdk.httpclient.models.GetExchangesFilter
 import tbdex.sdk.httpclient.models.GetOfferingsFilter
 import tbdex.sdk.httpclient.models.TbdexResponseException
 import tbdex.sdk.protocol.Validator
+import tbdex.sdk.protocol.models.Balance
 import tbdex.sdk.protocol.models.Close
 import tbdex.sdk.protocol.models.Message
 import tbdex.sdk.protocol.models.Offering
@@ -29,6 +30,8 @@ import web5.sdk.dids.did.BearerDid
  */
 object TbdexHttpClient {
   private val client = OkHttpClient()
+  private const val CONTENT_TYPE = "Content-Type"
+  private const val AUTHORIZATION = "Authorization"
   private val jsonMediaType = "application/json; charset=utf-8".toMediaType()
   private const val JSON_HEADER = "application/json"
 
@@ -41,6 +44,7 @@ object TbdexHttpClient {
    * @return A list of [Offering] matching the request.
    * @throws TbdexResponseException for request or response errors.
    */
+  @Suppress("SwallowedException")
   fun getOfferings(pfiDid: String, filter: GetOfferingsFilter? = null): List<Offering> {
     val pfiServiceEndpoint = getPfiServiceEndpoint(pfiDid)
     val baseUrl = "$pfiServiceEndpoint/offerings/"
@@ -64,7 +68,70 @@ object TbdexHttpClient {
         val jsonNode = jsonMapper.readTree(responseString)
         return jsonNode.get("data").elements()
           .asSequence()
-          .map { Offering.parse(it.toString()) }
+          .map {
+            try {
+              Offering.parse(it.toString())
+            } catch (e: Exception) {
+              throw TbdexResponseException(
+                "response status: ${response.code}",
+                errors = listOf(
+                  ErrorDetail(
+                    detail = "Failed to parse offering ${e.message}"
+                  )
+                )
+              )
+            }
+          }
+          .toList()
+      }
+
+      else -> throw buildResponseException(response)
+    }
+  }
+
+  /**
+   * Fetches balances from a PFI.
+   *
+   * @param pfiDid The decentralized identifier of the PFI.
+   * @param requesterDid The decentralized identifier of the entity requesting the balances.
+   * @return A list of [Balance] matching the request.
+   * @throws TbdexResponseException for request or response errors.
+   */
+  @Suppress("SwallowedException")
+  fun getBalances(pfiDid: String, requesterDid: BearerDid): List<Balance> {
+    val pfiServiceEndpoint = getPfiServiceEndpoint(pfiDid)
+    val baseUrl = "$pfiServiceEndpoint/balances/"
+    val requestToken = RequestToken.generate(requesterDid, pfiDid)
+
+    val request = Request.Builder()
+      .url(baseUrl)
+      .addHeader(CONTENT_TYPE, JSON_HEADER)
+      .addHeader(AUTHORIZATION, "Bearer $requestToken")
+      .get()
+      .build()
+
+    val response: Response = client.newCall(request).execute()
+    when {
+      response.isSuccessful -> {
+        val responseString = response.body?.string()
+        // response body is an object with a data field
+        val jsonNode = jsonMapper.readTree(responseString)
+        return jsonNode.get("data").elements()
+          .asSequence()
+          .map {
+            try {
+              Balance.parse(it.toString())
+            } catch (e: Exception) {
+              throw TbdexResponseException(
+                "response status: ${response.code}",
+                errors = listOf(
+                  ErrorDetail(
+                    detail = "Failed to parse balance ${e.message}"
+                  )
+                )
+              )
+            }
+          }
           .toList()
       }
 
@@ -115,7 +182,7 @@ object TbdexHttpClient {
 
     val request = Request.Builder()
       .url(url)
-      .addHeader("Content-Type", JSON_HEADER)
+      .addHeader(CONTENT_TYPE, JSON_HEADER)
       .post(requestBody)
       .build()
 
@@ -170,7 +237,7 @@ object TbdexHttpClient {
 
     val request = Request.Builder()
       .url(url)
-      .addHeader("Content-Type", JSON_HEADER)
+      .addHeader(CONTENT_TYPE, JSON_HEADER)
       .put(requestBody)
       .build()
 
@@ -195,8 +262,8 @@ object TbdexHttpClient {
 
     val request = Request.Builder()
       .url(baseUrl)
-      .addHeader("Content-Type", JSON_HEADER)
-      .addHeader("Authorization", "Bearer $requestToken")
+      .addHeader(CONTENT_TYPE, JSON_HEADER)
+      .addHeader(AUTHORIZATION, "Bearer $requestToken")
       .get()
       .build()
 
@@ -237,8 +304,8 @@ object TbdexHttpClient {
 
     val request = Request.Builder()
       .url(httpUrlBuilder.build())
-      .addHeader("Content-Type", JSON_HEADER)
-      .addHeader("Authorization", "Bearer $requestToken")
+      .addHeader(CONTENT_TYPE, JSON_HEADER)
+      .addHeader(AUTHORIZATION, "Bearer $requestToken")
       .get()
       .build()
 

httpclient/src/test/kotlin/tbdex/sdk/httpclient/TbdexHttpClientTest.kt

@@ -86,6 +86,42 @@ class TbdexHttpClientTest {
     assertThrows<TbdexResponseException> { TbdexHttpClient.getOfferings(pfiDid.uri, null) }
   }
 
+  @Test
+  fun `get balances success via mockwebserver`() {
+    val balance = TestData.getBalance()
+    balance.sign(TestData.PFI_DID)
+    val mockBalance = listOf(balance)
+    val mockResponseString = Json.jsonMapper.writeValueAsString(mapOf("data" to mockBalance))
+    server.enqueue(MockResponse().setBody(mockResponseString).setResponseCode(HttpURLConnection.HTTP_OK))
+
+    val requesterDid = DidDht.create(InMemoryKeyManager())
+    val response = TbdexHttpClient.getBalances(pfiDid.uri, requesterDid)
+
+    assertEquals(1, response.size)
+  }
+
+  @Test
+  fun `get balances fail via mockwebserver`() {
+    val errorDetails = mapOf(
+      "errors" to listOf(
+        ErrorDetail(
+          id = "1",
+          status = "401",
+          code = "Unauthorized",
+          title = "Unauthorized",
+          detail = "The request is unauthorized.",
+          source = null,
+          meta = null
+        )
+      )
+    )
+
+    val mockResponseString = Json.jsonMapper.writeValueAsString(errorDetails)
+    server.enqueue(MockResponse().setBody(mockResponseString).setResponseCode(HttpURLConnection.HTTP_BAD_REQUEST))
+    val requesterDid = DidDht.create(InMemoryKeyManager())
+    assertThrows<TbdexResponseException> { TbdexHttpClient.getBalances(pfiDid.uri, requesterDid) }
+  }
+
   @Test
   fun `createExchange(Rfq) submits RFQ`() {
 

httpclient/src/test/kotlin/tbdex/sdk/httpclient/TestData.kt

@@ -2,6 +2,8 @@ package tbdex.sdk.httpclient
 
 import com.danubetech.verifiablecredentials.CredentialSubject
 import de.fxlae.typeid.TypeId
+import tbdex.sdk.protocol.models.Balance
+import tbdex.sdk.protocol.models.BalanceData
 import tbdex.sdk.protocol.models.MessageKind
 import tbdex.sdk.protocol.models.Offering
 import tbdex.sdk.protocol.models.OfferingData
@@ -74,6 +76,16 @@ object TestData {
     return offering
   }
 
+  fun getBalance() =
+    Balance.create(
+      from = PFI_DID.uri,
+      data = BalanceData(
+        currencyCode = "BTC",
+        available = "0.001",
+      )
+    )
+
+
   fun getRfq(
     to: String = PFI_DID.uri,
     offeringId: String = TypeId.generate(ResourceKind.offering.name).toString(),

httpserver/src/main/kotlin/tbdex/sdk/httpserver/TbdexHttpServer.kt

@@ -18,13 +18,16 @@ import io.ktor.server.routing.put
 import io.ktor.server.routing.route
 import io.ktor.server.routing.routing
 import tbdex.sdk.httpserver.handlers.createExchange
+import tbdex.sdk.httpserver.handlers.getBalances
 import tbdex.sdk.httpserver.handlers.getExchange
 import tbdex.sdk.httpserver.handlers.getExchanges
 import tbdex.sdk.httpserver.handlers.getOfferings
 import tbdex.sdk.httpserver.handlers.submitMessage
+import tbdex.sdk.httpserver.models.BalancesApi
 import tbdex.sdk.httpserver.models.Callbacks
 import tbdex.sdk.httpserver.models.CreateExchangeCallback
 import tbdex.sdk.httpserver.models.ExchangesApi
+import tbdex.sdk.httpserver.models.FakeBalancesApi
 import tbdex.sdk.httpserver.models.FakeExchangesApi
 import tbdex.sdk.httpserver.models.FakeOfferingsApi
 import tbdex.sdk.httpserver.models.GetExchangeCallback
@@ -59,7 +62,8 @@ class TbdexHttpServerConfig(
   val port: Int,
   val pfiDid: String? = null,
   val offeringsApi: OfferingsApi? = null,
-  val exchangesApi: ExchangesApi? = null
+  val exchangesApi: ExchangesApi? = null,
+  val balancesApi: BalancesApi? = null
 )
 
 
@@ -77,6 +81,7 @@ class TbdexHttpServer(private val config: TbdexHttpServerConfig) {
   internal val pfiDid = config.pfiDid ?: "did:ex:pfi"
   internal val offeringsApi = config.offeringsApi ?: FakeOfferingsApi()
   internal val exchangesApi = config.exchangesApi ?: FakeExchangesApi()
+  internal val balancesApi = config.balancesApi ?: FakeBalancesApi()
 
   /**
    * Configures the Ktor application with necessary settings, including content negotiation.
@@ -102,6 +107,23 @@ class TbdexHttpServer(private val config: TbdexHttpServerConfig) {
         )
       }
 
+      get("/offerings") {
+        getOfferings(
+          call,
+          offeringsApi,
+          callbacks.getOfferings
+        )
+      }
+
+      get("/balances") {
+        getBalances(
+          call,
+          balancesApi,
+          callbacks.getBalances,
+          pfiDid
+        )
+      }
+
       route("/exchanges") {
         post {
           createExchange(
@@ -139,13 +161,6 @@ class TbdexHttpServer(private val config: TbdexHttpServerConfig) {
         }
       }
 
-      get("/offerings") {
-        getOfferings(
-          call,
-          offeringsApi,
-          callbacks.getOfferings
-        )
-      }
     }
   }
 

httpserver/src/main/kotlin/tbdex/sdk/httpserver/handlers/GetBalances.kt

@@ -0,0 +1,105 @@
+package tbdex.sdk.httpserver.handlers
+
+import io.ktor.http.HttpHeaders
+import io.ktor.http.HttpStatusCode
+import io.ktor.server.application.ApplicationCall
+import io.ktor.server.response.respond
+import tbdex.sdk.httpclient.RequestToken
+import tbdex.sdk.httpclient.models.ErrorDetail
+import tbdex.sdk.httpserver.models.BalancesApi
+import tbdex.sdk.httpserver.models.CallbackError
+import tbdex.sdk.httpserver.models.ErrorResponse
+import tbdex.sdk.httpserver.models.GetBalancesCallback
+import tbdex.sdk.protocol.models.Balance
+
+/**
+ * Get balances response
+ *
+ * @property data list of Balances
+ */
+class GetBalancesResponse(
+  val data: List<Balance>?
+)
+/**
+ * Get balances request handler
+ *
+ * @param call Ktor server application call
+ * @param balancesApi Balances API interface
+ * @param callback Callback function to be invoked
+ */
+@Suppress("SwallowedException")
+suspend fun getBalances(
+  call: ApplicationCall,
+  balancesApi: BalancesApi,
+  callback: GetBalancesCallback?,
+  pfiDid: String
+) {
+
+  val authzHeader = call.request.headers[HttpHeaders.Authorization]
+  if (authzHeader == null) {
+    call.respond(
+      HttpStatusCode.Unauthorized,
+      ErrorResponse(
+        errors = listOf(
+          ErrorDetail(
+            detail = "Authorization header required"
+          )
+        )
+      )
+    )
+    return
+  }
+
+  val arr = authzHeader.split("Bearer ")
+  if (arr.size != 2) {
+    call.respond(
+      HttpStatusCode.Unauthorized,
+      ErrorResponse(
+        errors = listOf(
+          ErrorDetail(
+            detail = "Malformed Authorization header. Expected: Bearer TOKEN_HERE"
+          )
+        )
+      )
+    )
+    return
+  }
+
+  val token = arr[1]
+  val requesterDid: String
+  try {
+    requesterDid = RequestToken.verify(token, pfiDid)
+  } catch (e: Exception) {
+    call.respond(
+      HttpStatusCode.Unauthorized,
+      ErrorResponse(
+        errors = listOf(
+          ErrorDetail(
+            detail = "Could not verify Authorization header."
+          )
+        )
+      )
+    )
+    return
+  }
+
+  val balances = balancesApi.getBalances(requesterDid)
+
+  if (callback == null) {
+    call.respond(HttpStatusCode.OK, GetBalancesResponse(data = balances))
+    return
+  }
+
+  try {
+    callback.invoke(call)
+  } catch (e: CallbackError) {
+    call.respond(e.statusCode, ErrorResponse(e.details))
+    return
+  } catch (e: Exception) {
+    val errorDetail = ErrorDetail(detail = e.message ?: "Unknown error while getting Balances")
+    call.respond(HttpStatusCode.InternalServerError, ErrorResponse(listOf(errorDetail)))
+    return
+  }
+
+  call.respond(HttpStatusCode.OK, GetBalancesResponse(data = balances))
+}