libeufin

PreparedTransferApi.kt (5461B)

---

 /*
  * This file is part of LibEuFin.
  * Copyright (C) 2026 Taler Systems S.A.
 
  * LibEuFin is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as
  * published by the Free Software Foundation; either version 3, or
  * (at your option) any later version.
 
  * LibEuFin is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General
  * Public License for more details.
 
  * You should have received a copy of the GNU Affero General Public
  * License along with LibEuFin; see the file COPYING.  If not, see
  * <http://www.gnu.org/licenses/>
  */
 
 package tech.libeufin.bank.api
 
 import io.ktor.http.*
 import io.ktor.server.request.*
 import io.ktor.server.response.*
 import io.ktor.server.routing.*
 import io.github.smiley4.ktoropenapi.*
 import io.ktor.util.pipeline.*
 import tech.libeufin.bank.*
 import tech.libeufin.bank.auth.pathUsername
 import tech.libeufin.bank.db.Database
 import tech.libeufin.bank.db.TransferDAO.RegistrationResult
 import tech.libeufin.common.*
 import tech.libeufin.common.crypto.CryptoUtil
 import java.time.Instant
 import java.time.Duration
 
 fun Routing.preparedTransferApi(db: Database, cfg: BankConfig) {
     get("/taler-prepared-transfer/config", {
         operationId = "getPreparedTransferConfig"
         description = "Get the configuration of the prepared transfer API"
         tags = listOf("Prepared Transfer")
         request {
             pathParameter<String>("USERNAME") { description = "Account username" }
         }
         response {
             code(HttpStatusCode.OK) { description = "Configuration of the prepared transfer API"; body<PreparedTransferConfig>() }
         }
     }) {
         call.respond(
             PreparedTransferConfig(
                 currency = cfg.regionalCurrency,
                 supported_formats = listOf(SubjectFormat.SIMPLE)
             )
         )
     }
     post("/taler-prepared-transfer/registration", {
         operationId = "registerTransfer"
         description = "Register a prepared transfer"
         tags = listOf("Prepared Transfer")
         request {
             body<SubjectRequest>()
         }
         response {
             code(HttpStatusCode.OK) { description = "Registration successful"; body<SubjectResult>() }
             code(HttpStatusCode.Conflict) { description = "Reserve pub or subject derivation already used" }
         }
     }) {
         val req = call.receive<SubjectRequest>()
         cfg.checkRegionalCurrency(req.credit_amount)
 
         if (!req.verify())
             throw forbidden(
                 "invalid signature",
                 TalerErrorCode.BANK_BAD_SIGNATURE
             )
 
         when (val result = db.transfer.register(
             req.credit_account,
             req.type,
             req.account_pub,
             req.authorization_pub,
             req.authorization_sig,
             req.recurrent,
             req.credit_amount,
             Instant.now()
         )) {
             RegistrationResult.NotExchange -> throw notExchange(req.credit_account.canonical)
             RegistrationResult.ReservePubReuse -> throw conflict(
                 "reserve_pub used already",
                 TalerErrorCode.BANK_DUPLICATE_RESERVE_PUB_SUBJECT
             )
             RegistrationResult.UnknownCreditor -> throw unknownCreditorAccount(req.credit_account.canonical)
             is RegistrationResult.Success -> {
                 val subjects = mutableListOf<TransferSubject>()
                 if (result.uuid != null)
                     subjects.add(TransferSubject.Uri(cfg.talerWithdrawUri(result.uuid), req.credit_amount))
                 subjects.add(TransferSubject.Simple(fmtIncomingSubject(IncomingType.map, req.authorization_pub), req.credit_amount))
                 call.respond(
                     SubjectResult(
                         subjects,
                         TalerTimestamp.never()
                     )
                 )
             }
         }
     }
     post("/taler-prepared-transfer/unregistration", {
         operationId = "unregisterTransfer"
         description = "Unregister a prepared subject"
         tags = listOf("Prepared Transfer")
         response {
             code(HttpStatusCode.NoContent) { description = "Successfully unregistered" }
             code(HttpStatusCode.NotFound) { description = "Prepared transfer not found" }
             code(HttpStatusCode.Conflict) { description = "Invalid signature or timestamp too old" }
         }
     }) {
         val req = call.receive<Unregistration>();
     
         logger.error("${req.nbo().joinToString(", ") { (it.toInt() and 0xFF).toString() }}")
 
         if (req.timestamp.instant.isBefore(Instant.now().minus(Duration.ofMinutes(15))))
             throw conflict(
                 "timestamp too old",
                 TalerErrorCode.BANK_OLD_TIMESTAMP
             )
 
         if (!req.verify())
             throw forbidden(
                 "invalid signature",
                 TalerErrorCode.BANK_BAD_SIGNATURE
             )
 
         if (db.transfer.unregister(req.authorization_pub, Instant.now())) {
             call.respond(HttpStatusCode.NoContent)
         } else {
             throw notFound(
                 "Prepared transfer '${req.authorization_pub}' not found",
                 TalerErrorCode.BANK_TRANSACTION_NOT_FOUND
             )
         }
     }
 }