path: root/c2ec/wire-gateway.go

package main

import (
	"context"
	"log"
	http "net/http"
	"strconv"
	"time"
)

const WIRE_GATEWAY_CONFIG_ENDPOINT = "/config"
const WIRE_GATEWAY_HISTORY_ENDPOINT = "/history"

const WIRE_GATEWAY_CONFIG_PATTERN = WIRE_GATEWAY_CONFIG_ENDPOINT
const WIRE_TRANSFER_PATTERN = "/transfer"
const WIRE_HISTORY_INCOMING_PATTERN = WIRE_GATEWAY_HISTORY_ENDPOINT + "/incoming"
const WIRE_HISTORY_OUTGOING_PATTERN = WIRE_GATEWAY_HISTORY_ENDPOINT + "/outgoing"
const WIRE_ADMIN_ADD_INCOMING_PATTERN = "/admin/add-incoming"

const INCOMING_RESERVE_TRANSACTION_TYPE = "RESERVE"

// https://docs.taler.net/core/api-bank-wire.html#tsref-type-WireConfig
type WireConfig struct {
	Name           string `json:"name"`
	Version        string `json:"version"`
	Currency       string `json:"currency"`
	Implementation string `json:"implementation"`
}

// https://docs.taler.net/core/api-bank-wire.html#tsref-type-TransferRequest
type TransferRequest struct {
	RequestUid      HashCode      `json:"request_uid"`
	Amount          Amount        `json:"amount"`
	ExchangeBaseUrl string        `json:"exchange_base_url"`
	Wtid            ShortHashCode `json:"wtid"`
	CreditAccount   string        `json:"credit_account"`
}

// https://docs.taler.net/core/api-bank-wire.html#tsref-type-TransferResponse
type TransferResponse struct {
	Timestamp Timestamp `json:"timestamp"`
	RowId     int       `json:"row_id"`
}

// https://docs.taler.net/core/api-bank-wire.html#tsref-type-IncomingHistory
type IncomingHistory struct {
	IncomingTransactions []IncomingReserveTransaction `json:"incoming_transactions"`
	CreditAccount        string                       `json:"credit_account"`
}

// type RESERVE | https://docs.taler.net/core/api-bank-wire.html#tsref-type-IncomingReserveTransaction
type IncomingReserveTransaction struct {
	Type         string         `json:"type"`
	RowId        int            `json:"row_id"`
	Date         Timestamp      `json:"date"`
	Amount       Amount         `json:"amount"`
	DebitAccount string         `json:"debit_account"`
	ReservePub   EddsaPublicKey `json:"reserve_pub"`
}

type OutgoingHistory struct {
	OutgoingTransactions []*OutgoingBankTransaction `json:"outgoing_transactions"`
	DebitAccount         string                     `json:"debit_account"`
}

type OutgoingBankTransaction struct {
	RowId           uint64        `json:"row_id"`
	Date            Timestamp     `json:"date"`
	Amount          Amount        `json:"amount"`
	CreditAccount   string        `json:"credit_account"`
	Wtid            ShortHashCode `json:"wtid"`
	ExchangeBaseUrl string        `json:"exchange_base_url"`
}

func NewIncomingReserveTransaction(w *Withdrawal) *IncomingReserveTransaction {
	t := new(IncomingReserveTransaction)
	t.Amount = Amount{
		Value:    uint64(w.Amount.Val),
		Fraction: uint64(w.Amount.Frac),
		Currency: w.Amount.Curr,
	}
	t.Date = Timestamp{
		Ts: int(w.RegistrationTs),
	}
	t.DebitAccount = "" // TODO provider specific payto uri -> needs new interface operation
	t.ReservePub = EddsaPublicKey(w.ReservePubKey)
	t.RowId = int(w.WithdrawalId)
	t.Type = INCOMING_RESERVE_TRANSACTION_TYPE
	return t
}

func NewOutgoingBankTransaction(tr *Transfer) *OutgoingBankTransaction {
	t := new(OutgoingBankTransaction)
	t.Amount = Amount{
		Value:    uint64(tr.Amount.Val),
		Fraction: uint64(tr.Amount.Frac),
		Currency: tr.Amount.Curr,
	}
	t.Date = Timestamp{
		Ts: int(tr.TransactionTs),
	}
	t.CreditAccount = tr.CreditAccount
	t.ExchangeBaseUrl = tr.ExchangeBaseUrl
	t.RowId = uint64(tr.RowId)
	t.Wtid = ShortHashCode(tr.Wtid)
	return t
}

func wireGatewayConfig(res http.ResponseWriter, req *http.Request) {

	cfg := WireConfig{
		Name:    "taler-wire-gateway",
		Version: "0:0:1",
	}

	serializedCfg, err := NewJsonCodec[WireConfig]().EncodeToBytes(&cfg)
	if err != nil {
		log.Default().Printf("failed serializing config: %s", err.Error())
		res.WriteHeader(HTTP_INTERNAL_SERVER_ERROR)
		return
	}

	res.WriteHeader(HTTP_OK)
	res.Write(serializedCfg)
}

func transfer(res http.ResponseWriter, req *http.Request) {

	jsonCodec := NewJsonCodec[TransferRequest]()
	transfer, err := ReadStructFromBody(req, jsonCodec)
	if err != nil {

		err := WriteProblem(res, HTTP_BAD_REQUEST, &RFC9457Problem{
			TypeUri:  TALER_URI_PROBLEM_PREFIX + "/C2EC_TRANSFER_INVALID_REQ",
			Title:    "invalid request",
			Detail:   "the transfer request is malformed (error: " + err.Error() + ")",
			Instance: req.RequestURI,
		})
		if err != nil {
			res.WriteHeader(HTTP_INTERNAL_SERVER_ERROR)
		}
		return
	}

	paytoTargetType, tid, err := ParsePaytoWalleeTransaction(transfer.CreditAccount)
	if err != nil {
		err := WriteProblem(res, HTTP_BAD_REQUEST, &RFC9457Problem{
			TypeUri:  TALER_URI_PROBLEM_PREFIX + "/C2EC_TRANSFER_INVALID_REQ",
			Title:    "invalid payto-uri",
			Detail:   "the transfer request contains an invalid payto-uri (error: " + err.Error() + ")",
			Instance: req.RequestURI,
		})
		if err != nil {
			res.WriteHeader(HTTP_INTERNAL_SERVER_ERROR)
		}
		return
	}

	p, err := DB.GetTerminalProviderByPaytoTargetType(paytoTargetType)
	if err != nil {
		err := WriteProblem(res, HTTP_INTERNAL_SERVER_ERROR, &RFC9457Problem{
			TypeUri:  TALER_URI_PROBLEM_PREFIX + "/C2EC_DATABASE_FAILURE",
			Title:    "database request failed",
			Detail:   "failed to retrieve the provider for the payto target type '" + paytoTargetType + "'",
			Instance: req.RequestURI,
		})
		if err != nil {
			res.WriteHeader(HTTP_INTERNAL_SERVER_ERROR)
		}
		return
	}

	t, err := DB.GetTransferById(transfer.RequestUid)
	if err != nil {
		err := WriteProblem(res, HTTP_INTERNAL_SERVER_ERROR, &RFC9457Problem{
			TypeUri:  TALER_URI_PROBLEM_PREFIX + "/C2EC_DATABASE_FAILURE",
			Title:    "database request failed",
			Detail:   "there was an error processing the database query",
			Instance: req.RequestURI,
		})
		if err != nil {
			res.WriteHeader(HTTP_INTERNAL_SERVER_ERROR)
		}
		return
	}

	if t == nil {
		// no transfer for this request_id -> generate new
		err := DB.AddTransfer(
			transfer.RequestUid,
			&transfer.Amount,
			transfer.ExchangeBaseUrl,
			string(transfer.Wtid),
			transfer.CreditAccount,
		)
		if err != nil {
			err := WriteProblem(res, HTTP_INTERNAL_SERVER_ERROR, &RFC9457Problem{
				TypeUri:  TALER_URI_PROBLEM_PREFIX + "/C2EC_DATABASE_FAILURE",
				Title:    "database request failed",
				Detail:   "there was an error creating the transfer",
				Instance: req.RequestURI,
			})
			if err != nil {
				res.WriteHeader(HTTP_INTERNAL_SERVER_ERROR)
			}
			return
		}
	} else {
		// the transfer is only processed if the body matches.
		if transfer.Amount.Value != uint64(t.Amount.Val) ||
			transfer.Amount.Fraction != uint64(t.Amount.Frac) ||
			transfer.Amount.Currency != t.Amount.Curr ||
			transfer.ExchangeBaseUrl != t.ExchangeBaseUrl ||
			transfer.Wtid != ShortHashCode(t.Wtid) ||
			transfer.CreditAccount != t.CreditAccount {

			err := WriteProblem(res, HTTP_CONFLICT, &RFC9457Problem{
				TypeUri:  TALER_URI_PROBLEM_PREFIX + "/C2EC_TRANSFER_INVALID_REQ",
				Title:    "invalid request",
				Detail:   "the transfer request did not match previous request with the same request identifier",
				Instance: req.RequestURI,
			})
			if err != nil {
				res.WriteHeader(HTTP_INTERNAL_SERVER_ERROR)
			}
			return
		}

		ptid := strconv.Itoa(tid)
		w, err := DB.GetWithdrawalByProviderTransactionId(ptid)
		if err != nil || w == nil {
			err := WriteProblem(res, HTTP_INTERNAL_SERVER_ERROR, &RFC9457Problem{
				TypeUri:  TALER_URI_PROBLEM_PREFIX + "/C2EC_DATABASE_FAILURE",
				Title:    "database request failed",
				Detail:   "there was an error processing the database query or no withdrawal could been found.",
				Instance: req.RequestURI,
			})
			if err != nil {
				res.WriteHeader(HTTP_INTERNAL_SERVER_ERROR)
			}
			return
		}

		refundClient := PROVIDER_CLIENTS[p.Name]
		if refundClient == nil {
			err := WriteProblem(res, HTTP_INTERNAL_SERVER_ERROR, &RFC9457Problem{
				TypeUri:  TALER_URI_PROBLEM_PREFIX + "/C2EC_UNKNOWN_TRANSFER_MECHANISM",
				Title:    "unknown refund mechanism",
				Detail:   "the target type of the payto uri for the transfer is not registered",
				Instance: req.RequestURI,
			})
			if err != nil {
				res.WriteHeader(HTTP_INTERNAL_SERVER_ERROR)
			}
			return
		}
		refundClient.Refund(ptid)
	}
}

// :query start: *Optional.*
//
//	Row identifier to explicitly set the *starting point* of the query.
//
// :query delta:
//
//	The *delta* value that determines the range of the query.
//
// :query long_poll_ms: *Optional.*
//
//	If this parameter is specified and the result of the query would be empty,
//	the bank will wait up to ``long_poll_ms`` milliseconds for new transactions
//	that match the query to arrive and only then send the HTTP response.
//	A client must never rely on this behavior, as the bank may return a response
//	immediately or after waiting only a fraction of ``long_poll_ms``.
func historyIncoming(res http.ResponseWriter, req *http.Request) {

	// read and validate request query parameters
	shouldStartLongPoll := true
	var longPollMilli int
	if longPollMilliPtr, accepted := AcceptOptionalParamOrWriteResponse(
		"long_poll_ms", strconv.Atoi, req, res,
	); accepted {
	} else {
		if longPollMilliPtr != nil {
			longPollMilli = *longPollMilliPtr
		} else {
			// this means parameter was not given.
			// no long polling (simple get)
			shouldStartLongPoll = false
		}
	}

	var start int
	if startPtr, accepted := AcceptOptionalParamOrWriteResponse(
		"start", strconv.Atoi, req, res,
	); accepted {
	} else {
		if startPtr != nil {
			start = *startPtr
		}
	}

	var delta int
	if deltaPtr, accepted := AcceptOptionalParamOrWriteResponse(
		"delta", strconv.Atoi, req, res,
	); accepted {
	} else {
		if deltaPtr != nil {
			delta = *deltaPtr
		} else {
			// this means parameter was not given.
			// no long polling (simple get)
			shouldStartLongPoll = false
		}
	}

	if shouldStartLongPoll {

		// wait for the completion of the context
		waitMs, cancelFunc := context.WithTimeout(req.Context(), time.Duration(longPollMilli)*time.Millisecond)
		defer cancelFunc()

		// this will just wait / block until the milliseconds are exceeded.
		<-waitMs.Done()
	}

	withdrawals, err := DB.GetConfirmedWithdrawals(start, delta)

	if err != nil {
		err := WriteProblem(res, HTTP_INTERNAL_SERVER_ERROR, &RFC9457Problem{
			TypeUri:  TALER_URI_PROBLEM_PREFIX + "/C2EC_DATABASE_FAILURE",
			Title:    "database request failed",
			Detail:   "there was an error processing the database query",
			Instance: req.RequestURI,
		})
		if err != nil {
			res.WriteHeader(HTTP_INTERNAL_SERVER_ERROR)
		}
		return
	}

	if len(withdrawals) < 1 {
		res.WriteHeader(HTTP_NOT_FOUND)
		return
	}

	transactions := make([]*IncomingReserveTransaction, len(withdrawals))
	for _, w := range withdrawals {
		transactions = append(transactions, NewIncomingReserveTransaction(w))
	}

	enc, err := NewJsonCodec[[]*IncomingReserveTransaction]().EncodeToBytes(&transactions)
	if err != nil {
		err := WriteProblem(res, HTTP_INTERNAL_SERVER_ERROR, &RFC9457Problem{
			TypeUri:  TALER_URI_PROBLEM_PREFIX + "/C2EC_RESPONSE_ENCODING_FAILED",
			Title:    "encoding failed",
			Detail:   "the encoding of the response failed (error:" + err.Error() + ")",
			Instance: req.RequestURI,
		})
		if err != nil {
			res.WriteHeader(HTTP_INTERNAL_SERVER_ERROR)
		}
		return
	}

	res.WriteHeader(HTTP_OK)
	res.Write(enc)
}

func historyOutgoing(res http.ResponseWriter, req *http.Request) {

	// read and validate request query parameters
	shouldStartLongPoll := true
	var longPollMilli int
	if longPollMilliPtr, accepted := AcceptOptionalParamOrWriteResponse(
		"long_poll_ms", strconv.Atoi, req, res,
	); accepted {
	} else {
		if longPollMilliPtr != nil {
			longPollMilli = *longPollMilliPtr
		} else {
			// this means parameter was not given.
			// no long polling (simple get)
			shouldStartLongPoll = false
		}
	}

	var start int
	if startPtr, accepted := AcceptOptionalParamOrWriteResponse(
		"start", strconv.Atoi, req, res,
	); accepted {
	} else {
		if startPtr != nil {
			start = *startPtr
		}
	}

	var delta int
	if deltaPtr, accepted := AcceptOptionalParamOrWriteResponse(
		"delta", strconv.Atoi, req, res,
	); accepted {
	} else {
		if deltaPtr != nil {
			delta = *deltaPtr
		} else {
			// this means parameter was not given.
			// no long polling (simple get)
			shouldStartLongPoll = false
		}
	}

	if shouldStartLongPoll {

		// wait for the completion of the context
		waitMs, cancelFunc := context.WithTimeout(req.Context(), time.Duration(longPollMilli)*time.Millisecond)
		defer cancelFunc()

		// this will just wait / block until the milliseconds are exceeded.
		<-waitMs.Done()
	}

	transfers, err := DB.GetTransfers(start, delta)

	if err != nil {
		err := WriteProblem(res, HTTP_INTERNAL_SERVER_ERROR, &RFC9457Problem{
			TypeUri:  TALER_URI_PROBLEM_PREFIX + "/C2EC_DATABASE_FAILURE",
			Title:    "database request failed",
			Detail:   "there was an error processing the database query",
			Instance: req.RequestURI,
		})
		if err != nil {
			res.WriteHeader(HTTP_INTERNAL_SERVER_ERROR)
		}
		return
	}

	if len(transfers) < 1 {
		res.WriteHeader(HTTP_NOT_FOUND)
		return
	}

	transactions := make([]*OutgoingBankTransaction, len(transfers))
	for _, t := range transfers {
		transactions = append(transactions, NewOutgoingBankTransaction(t))
	}

	outgoingHistory := OutgoingHistory{
		OutgoingTransactions: transactions,
		DebitAccount:         CONFIG.Server.CreditAccount,
	}
	enc, err := NewJsonCodec[OutgoingHistory]().EncodeToBytes(&outgoingHistory)
	if err != nil {
		err := WriteProblem(res, HTTP_INTERNAL_SERVER_ERROR, &RFC9457Problem{
			TypeUri:  TALER_URI_PROBLEM_PREFIX + "/C2EC_RESPONSE_ENCODING_FAILED",
			Title:    "encoding failed",
			Detail:   "the encoding of the response failed (error:" + err.Error() + ")",
			Instance: req.RequestURI,
		})
		if err != nil {
			res.WriteHeader(HTTP_INTERNAL_SERVER_ERROR)
		}
		return
	}

	res.WriteHeader(HTTP_OK)
	res.Write(enc)
}

// This method is currently dead and implemented for API conformance
func adminAddIncoming(res http.ResponseWriter, req *http.Request) {

	// not implemented, because not used
	res.WriteHeader(HTTP_BAD_REQUEST)
}