Merge all three apps into one repository

30 files changed, 3916 insertions, 0 deletions

diff --git a/wallet/src/main/java/net/taler/wallet/Amount.kt b/wallet/src/main/java/net/taler/wallet/Amount.kt
new file mode 100644
index 0000000..a19e9bc
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/Amount.kt
@@ -0,0 +1,141 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+@file:Suppress("EXPERIMENTAL_API_USAGE", "EXPERIMENTAL_UNSIGNED_LITERALS")
+
+package net.taler.wallet
+
+import com.fasterxml.jackson.core.JsonParser
+import com.fasterxml.jackson.databind.DeserializationContext
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize
+import com.fasterxml.jackson.databind.deser.std.StdDeserializer
+import org.json.JSONObject
+import kotlin.math.round
+
+private const val FRACTIONAL_BASE = 1e8
+
+@JsonDeserialize(using = AmountDeserializer::class)
+data class Amount(val currency: String, val amount: String) {
+    fun isZero(): Boolean {
+        return amount.toDouble() == 0.0
+    }
+
+    companion object {
+        fun fromJson(jsonAmount: JSONObject): Amount {
+            val amountCurrency = jsonAmount.getString("currency")
+            val amountValue = jsonAmount.getString("value")
+            val amountFraction = jsonAmount.getString("fraction")
+            val amountIntValue = Integer.parseInt(amountValue)
+            val amountIntFraction = Integer.parseInt(amountFraction)
+            return Amount(
+                amountCurrency,
+                (amountIntValue + amountIntFraction / FRACTIONAL_BASE).toString()
+            )
+        }
+
+        fun fromString(strAmount: String): Amount {
+            val components = strAmount.split(":")
+            return Amount(components[0], components[1])
+        }
+    }
+
+    override fun toString(): String {
+        return String.format("%.2f $currency", amount.toDouble())
+    }
+}
+
+class AmountDeserializer : StdDeserializer<Amount>(Amount::class.java) {
+    override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Amount {
+        val node = p.codec.readValue(p, String::class.java)
+        return Amount.fromString(node)
+    }
+}
+
+class ParsedAmount(
+    /**
+     * name of the currency using either a three-character ISO 4217 currency code,
+     * or a regional currency identifier starting with a "*" followed by at most 10 characters.
+     * ISO 4217 exponents in the name are not supported,
+     * although the "fraction" is corresponds to an ISO 4217 exponent of 6.
+     */
+    val currency: String,
+
+    /**
+     * unsigned 32 bit value in the currency,
+     * note that "1" here would correspond to 1 EUR or 1 USD, depending on currency, not 1 cent.
+     */
+    val value: UInt,
+
+    /**
+     * unsigned 32 bit fractional value to be added to value
+     * representing an additional currency fraction,
+     * in units of one millionth (1e-6) of the base currency value.
+     * For example, a fraction of 500,000 would correspond to 50 cents.
+     */
+    val fraction: Double
+) {
+    companion object {
+        fun parseAmount(str: String): ParsedAmount {
+            val split = str.split(":")
+            check(split.size == 2)
+            val currency = split[0]
+            val valueSplit = split[1].split(".")
+            val value = valueSplit[0].toUInt()
+            val fraction: Double = if (valueSplit.size > 1) {
+                round("0.${valueSplit[1]}".toDouble() * FRACTIONAL_BASE)
+            } else 0.0
+            return ParsedAmount(currency, value, fraction)
+        }
+    }
+
+    operator fun minus(other: ParsedAmount): ParsedAmount {
+        check(currency == other.currency) { "Can only subtract from same currency" }
+        var resultValue = value
+        var resultFraction = fraction
+        if (resultFraction < other.fraction) {
+            if (resultValue < 1u) {
+                return ParsedAmount(currency, 0u, 0.0)
+            }
+            resultValue--
+            resultFraction += FRACTIONAL_BASE
+        }
+        check(resultFraction >= other.fraction)
+        resultFraction -= other.fraction
+        if (resultValue < other.value) {
+            return ParsedAmount(currency, 0u, 0.0)
+        }
+        resultValue -= other.value
+        return ParsedAmount(currency, resultValue, resultFraction)
+    }
+
+    fun isZero(): Boolean {
+        return value == 0u && fraction == 0.0
+    }
+
+    @Suppress("unused")
+    fun toJSONString(): String {
+        return "$currency:${getValueString()}"
+    }
+
+    override fun toString(): String {
+        return "${getValueString()} $currency"
+    }
+
+    private fun getValueString(): String {
+        return "$value${(fraction / FRACTIONAL_BASE).toString().substring(1)}"
+    }
+
+}
diff --git a/wallet/src/main/java/net/taler/wallet/BalanceFragment.kt b/wallet/src/main/java/net/taler/wallet/BalanceFragment.kt
new file mode 100644
index 0000000..84a1b3c
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/BalanceFragment.kt
@@ -0,0 +1,198 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+package net.taler.wallet
+
+import android.os.Bundle
+import android.transition.TransitionManager.beginDelayedTransition
+import android.util.Log
+import android.view.LayoutInflater
+import android.view.Menu
+import android.view.MenuInflater
+import android.view.MenuItem
+import android.view.View
+import android.view.View.GONE
+import android.view.View.VISIBLE
+import android.view.ViewGroup
+import android.widget.TextView
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.activityViewModels
+import androidx.lifecycle.Observer
+import androidx.recyclerview.widget.DividerItemDecoration
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.LinearLayoutManager.VERTICAL
+import androidx.recyclerview.widget.RecyclerView.Adapter
+import androidx.recyclerview.widget.RecyclerView.ViewHolder
+import com.google.zxing.integration.android.IntentIntegrator
+import com.google.zxing.integration.android.IntentIntegrator.QR_CODE_TYPES
+import kotlinx.android.synthetic.main.fragment_show_balance.*
+import net.taler.wallet.BalanceAdapter.BalanceViewHolder
+
+class BalanceFragment : Fragment() {
+
+    private val model: WalletViewModel by activityViewModels()
+    private val withdrawManager by lazy { model.withdrawManager }
+
+    private var reloadBalanceMenuItem: MenuItem? = null
+    private val balancesAdapter = BalanceAdapter()
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setHasOptionsMenu(true)
+    }
+
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View? {
+        return inflater.inflate(R.layout.fragment_show_balance, container, false)
+    }
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        balancesList.apply {
+            layoutManager = LinearLayoutManager(context)
+            adapter = balancesAdapter
+            addItemDecoration(DividerItemDecoration(context, VERTICAL))
+        }
+
+        model.balances.observe(viewLifecycleOwner, Observer {
+            onBalancesChanged(it)
+        })
+
+        model.devMode.observe(viewLifecycleOwner, Observer { enabled ->
+            delayedTransition()
+            testWithdrawButton.visibility = if (enabled) VISIBLE else GONE
+            reloadBalanceMenuItem?.isVisible = enabled
+        })
+        testWithdrawButton.setOnClickListener {
+            withdrawManager.withdrawTestkudos()
+        }
+        withdrawManager.testWithdrawalInProgress.observe(viewLifecycleOwner, Observer { loading ->
+            Log.v("taler-wallet", "observing balance loading $loading in show balance")
+            testWithdrawButton.isEnabled = !loading
+            model.showProgressBar.value = loading
+        })
+
+        scanButton.setOnClickListener {
+            IntentIntegrator(activity).apply {
+                setPrompt("")
+                setBeepEnabled(true)
+                setOrientationLocked(false)
+            }.initiateScan(QR_CODE_TYPES)
+        }
+    }
+
+    override fun onStart() {
+        super.onStart()
+        model.loadBalances()
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem): Boolean {
+        return when (item.itemId) {
+            R.id.reload_balance -> {
+                model.loadBalances()
+                true
+            }
+            R.id.developer_mode -> {
+                item.isChecked = !item.isChecked
+                model.devMode.value = item.isChecked
+                true
+            }
+            else -> super.onOptionsItemSelected(item)
+        }
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu, inflater: MenuInflater) {
+        inflater.inflate(R.menu.balance, menu)
+        menu.findItem(R.id.developer_mode).isChecked = model.devMode.value!!
+        reloadBalanceMenuItem = menu.findItem(R.id.reload_balance).apply {
+            isVisible = model.devMode.value!!
+        }
+        super.onCreateOptionsMenu(menu, inflater)
+    }
+
+    private fun onBalancesChanged(balances: List<BalanceItem>) {
+        delayedTransition()
+        if (balances.isEmpty()) {
+            balancesEmptyState.visibility = VISIBLE
+            balancesList.visibility = GONE
+        } else {
+            balancesAdapter.setItems(balances)
+            balancesEmptyState.visibility = GONE
+            balancesList.visibility = VISIBLE
+        }
+    }
+
+    private fun delayedTransition() {
+        beginDelayedTransition(view as ViewGroup)
+    }
+
+}
+
+class BalanceAdapter : Adapter<BalanceViewHolder>() {
+
+    private var items = emptyList<BalanceItem>()
+
+    init {
+        setHasStableIds(false)
+    }
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): BalanceViewHolder {
+        val v =
+            LayoutInflater.from(parent.context).inflate(R.layout.list_item_balance, parent, false)
+        return BalanceViewHolder(v)
+    }
+
+    override fun getItemCount() = items.size
+
+    override fun onBindViewHolder(holder: BalanceViewHolder, position: Int) {
+        val item = items[position]
+        holder.bind(item)
+    }
+
+    fun setItems(items: List<BalanceItem>) {
+        this.items = items
+        this.notifyDataSetChanged()
+    }
+
+    class BalanceViewHolder(private val v: View) : ViewHolder(v) {
+        private val currencyView: TextView = v.findViewById(R.id.balance_currency)
+        private val amountView: TextView = v.findViewById(R.id.balance_amount)
+        private val balanceInboundAmount: TextView = v.findViewById(R.id.balanceInboundAmount)
+        private val balanceInboundLabel: TextView = v.findViewById(R.id.balanceInboundLabel)
+
+        fun bind(item: BalanceItem) {
+            currencyView.text = item.available.currency
+            amountView.text = item.available.amount
+
+            val amountIncoming = item.pendingIncoming
+            if (amountIncoming.isZero()) {
+                balanceInboundAmount.visibility = GONE
+                balanceInboundLabel.visibility = GONE
+            } else {
+                balanceInboundAmount.visibility = VISIBLE
+                balanceInboundLabel.visibility = VISIBLE
+                balanceInboundAmount.text = v.context.getString(
+                    R.string.balances_inbound_amount,
+                    amountIncoming.amount,
+                    amountIncoming.currency
+                )
+            }
+        }
+    }
+
+}
diff --git a/wallet/src/main/java/net/taler/wallet/HostCardEmulatorService.kt b/wallet/src/main/java/net/taler/wallet/HostCardEmulatorService.kt
new file mode 100644
index 0000000..93f1d3f
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/HostCardEmulatorService.kt
@@ -0,0 +1,187 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+package net.taler.wallet
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.net.Uri
+import android.nfc.cardemulation.HostApduService
+import android.os.Bundle
+import android.util.Log
+import java.io.ByteArrayInputStream
+import java.io.ByteArrayOutputStream
+import java.util.concurrent.ConcurrentLinkedDeque
+
+fun makeApduSuccessResponse(payload: ByteArray): ByteArray {
+    val stream = ByteArrayOutputStream()
+    stream.write(payload)
+    stream.write(0x90)
+    stream.write(0x00)
+    return stream.toByteArray()
+}
+
+
+fun makeApduFailureResponse(): ByteArray {
+    val stream = ByteArrayOutputStream()
+    stream.write(0x6F)
+    stream.write(0x00)
+    return stream.toByteArray()
+}
+
+
+fun readApduBodySize(stream: ByteArrayInputStream): Int {
+    val b0 = stream.read()
+    if (b0 == -1) {
+        return 0
+    }
+    if (b0 != 0) {
+        return b0
+    }
+    val b1 = stream.read()
+    val b2 = stream.read()
+
+    return (b1 shl 8) and b2
+}
+
+
+class HostCardEmulatorService: HostApduService() {
+
+    val queuedRequests: ConcurrentLinkedDeque<String> = ConcurrentLinkedDeque()
+    private lateinit var receiver: BroadcastReceiver
+
+    override fun onCreate() {
+        super.onCreate()
+        receiver = object : BroadcastReceiver() {
+            override fun onReceive(p0: Context?, p1: Intent?) {
+                queuedRequests.addLast(p1!!.getStringExtra("tunnelMessage"))
+            }
+        }
+        IntentFilter(HTTP_TUNNEL_REQUEST).also { filter ->
+            registerReceiver(receiver, filter)
+        }
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        unregisterReceiver(receiver)
+    }
+
+    override fun onDeactivated(reason: Int) {
+        Log.d(TAG, "Deactivated: $reason")
+        Intent().also { intent ->
+            intent.action = MERCHANT_NFC_DISCONNECTED
+            sendBroadcast(intent)
+        }
+    }
+
+    override fun processCommandApdu(commandApdu: ByteArray?,
+                                    extras: Bundle?): ByteArray {
+
+        Log.d(TAG, "Processing command APDU")
+
+        if (commandApdu == null) {
+            Log.d(TAG, "APDU is null")
+            return makeApduFailureResponse()
+        }
+
+        val stream = ByteArrayInputStream(commandApdu)
+
+        val command = stream.read()
+
+        if (command != 0) {
+            Log.d(TAG, "APDU has invalid command")
+            return makeApduFailureResponse()
+        }
+
+        val instruction = stream.read()
+
+        // Read instruction parameters, currently ignored.
+        stream.read()
+        stream.read()
+
+        if (instruction == SELECT_INS) {
+            // FIXME: validate body!
+            return makeApduSuccessResponse(ByteArray(0))
+        }
+
+        if (instruction == GET_INS) {
+            val req = queuedRequests.poll()
+            return if (req != null) {
+                Log.v(TAG,"sending tunnel request")
+                makeApduSuccessResponse(req.toByteArray(Charsets.UTF_8))
+            } else {
+                makeApduSuccessResponse(ByteArray(0))
+            }
+        }
+
+        if (instruction == PUT_INS) {
+            val bodySize = readApduBodySize(stream)
+            val talerInstr = stream.read()
+            val bodyBytes = stream.readBytes()
+            if (1 + bodyBytes.size != bodySize) {
+                Log.w(TAG, "mismatched body size ($bodySize vs ${bodyBytes.size}")
+            }
+
+            when (talerInstr) {
+                1 -> {
+                    val url = String(bodyBytes, Charsets.UTF_8)
+                    Log.v(TAG, "got URL: '$url'")
+
+                    Intent(this, MainActivity::class.java).also { intent ->
+                        intent.data = Uri.parse(url)
+                        intent.action = Intent.ACTION_VIEW
+                        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                        startActivity(intent)
+                    }
+                }
+                2 -> {
+                    Log.v(TAG, "got http response: ${bodyBytes.toString(Charsets.UTF_8)}")
+
+                    Intent().also { intent ->
+                        intent.action = HTTP_TUNNEL_RESPONSE
+                        intent.putExtra("response", bodyBytes.toString(Charsets.UTF_8))
+                        sendBroadcast(intent)
+                    }
+                }
+                else -> {
+                    Log.v(TAG, "taler instruction $talerInstr unknown")
+                }
+            }
+
+            return makeApduSuccessResponse(ByteArray(0))
+        }
+
+        return makeApduFailureResponse()
+    }
+
+    companion object {
+        const val TAG = "taler-wallet-hce"
+        const val SELECT_INS = 0xA4
+        const val PUT_INS = 0xDA
+        const val GET_INS = 0xCA
+
+        const val TRIGGER_PAYMENT_ACTION = "net.taler.TRIGGER_PAYMENT_ACTION"
+
+        const val MERCHANT_NFC_CONNECTED = "net.taler.MERCHANT_NFC_CONNECTED"
+        const val MERCHANT_NFC_DISCONNECTED = "net.taler.MERCHANT_NFC_DISCONNECTED"
+
+        const val HTTP_TUNNEL_RESPONSE = "net.taler.HTTP_TUNNEL_RESPONSE"
+        const val HTTP_TUNNEL_REQUEST = "net.taler.HTTP_TUNNEL_REQUEST"
+    }
+}
\ No newline at end of file
diff --git a/wallet/src/main/java/net/taler/wallet/MainActivity.kt b/wallet/src/main/java/net/taler/wallet/MainActivity.kt
new file mode 100644
index 0000000..c2f20f7
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/MainActivity.kt
@@ -0,0 +1,209 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+package net.taler.wallet
+
+import android.annotation.SuppressLint
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.Intent.ACTION_VIEW
+import android.content.IntentFilter
+import android.os.Bundle
+import android.util.Log
+import android.view.MenuItem
+import android.view.View.GONE
+import android.view.View.INVISIBLE
+import android.view.View.VISIBLE
+import android.widget.TextView
+import androidx.activity.viewModels
+import androidx.appcompat.app.AppCompatActivity
+import androidx.core.view.GravityCompat.START
+import androidx.lifecycle.Observer
+import androidx.navigation.NavController
+import androidx.navigation.fragment.NavHostFragment
+import androidx.navigation.ui.AppBarConfiguration
+import androidx.navigation.ui.setupWithNavController
+import com.google.android.material.navigation.NavigationView.OnNavigationItemSelectedListener
+import com.google.android.material.snackbar.Snackbar
+import com.google.android.material.snackbar.Snackbar.LENGTH_SHORT
+import com.google.zxing.integration.android.IntentIntegrator
+import com.google.zxing.integration.android.IntentIntegrator.parseActivityResult
+import kotlinx.android.synthetic.main.activity_main.*
+import kotlinx.android.synthetic.main.app_bar_main.*
+import net.taler.wallet.BuildConfig.VERSION_CODE
+import net.taler.wallet.BuildConfig.VERSION_NAME
+import net.taler.wallet.HostCardEmulatorService.Companion.HTTP_TUNNEL_RESPONSE
+import net.taler.wallet.HostCardEmulatorService.Companion.MERCHANT_NFC_CONNECTED
+import net.taler.wallet.HostCardEmulatorService.Companion.MERCHANT_NFC_DISCONNECTED
+import net.taler.wallet.HostCardEmulatorService.Companion.TRIGGER_PAYMENT_ACTION
+import java.util.Locale.ROOT
+
+class MainActivity : AppCompatActivity(), OnNavigationItemSelectedListener,
+    ResetDialogEventListener {
+
+    private val model: WalletViewModel by viewModels()
+
+    private lateinit var nav: NavController
+
+    @SuppressLint("SetTextI18n")
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_main)
+
+        val navHostFragment =
+            supportFragmentManager.findFragmentById(R.id.nav_host_fragment) as NavHostFragment
+        nav = navHostFragment.navController
+        nav_view.setupWithNavController(nav)
+        nav_view.setNavigationItemSelectedListener(this)
+        if (savedInstanceState == null) {
+            nav_view.menu.getItem(0).isChecked = true
+        }
+
+        setSupportActionBar(toolbar)
+        val appBarConfiguration = AppBarConfiguration(
+            setOf(R.id.showBalance, R.id.settings, R.id.walletHistory, R.id.nav_pending_operations), drawer_layout
+        )
+        toolbar.setupWithNavController(nav, appBarConfiguration)
+
+        model.showProgressBar.observe(this, Observer { show ->
+            progress_bar.visibility = if (show) VISIBLE else INVISIBLE
+        })
+
+        val versionView: TextView = nav_view.getHeaderView(0).findViewById(R.id.versionView)
+        model.devMode.observe(this, Observer { enabled ->
+            nav_view.menu.findItem(R.id.nav_pending_operations).isVisible = enabled
+            if (enabled) {
+                @SuppressLint("SetTextI18n")
+                versionView.text = "$VERSION_NAME ($VERSION_CODE)"
+                versionView.visibility = VISIBLE
+            } else versionView.visibility = GONE
+        })
+
+        if (intent.action == ACTION_VIEW) intent.dataString?.let { uri ->
+            handleTalerUri(uri, "intent")
+        }
+
+        //model.startTunnel()
+
+        registerReceiver(triggerPaymentReceiver, IntentFilter(TRIGGER_PAYMENT_ACTION))
+        registerReceiver(nfcConnectedReceiver, IntentFilter(MERCHANT_NFC_CONNECTED))
+        registerReceiver(nfcDisconnectedReceiver, IntentFilter(MERCHANT_NFC_DISCONNECTED))
+        registerReceiver(tunnelResponseReceiver, IntentFilter(HTTP_TUNNEL_RESPONSE))
+    }
+
+    override fun onBackPressed() {
+        if (drawer_layout.isDrawerOpen(START)) drawer_layout.closeDrawer(START)
+        else super.onBackPressed()
+    }
+
+    override fun onNavigationItemSelected(item: MenuItem): Boolean {
+        when (item.itemId) {
+            R.id.nav_home -> nav.navigate(R.id.showBalance)
+            R.id.nav_settings -> nav.navigate(R.id.settings)
+            R.id.nav_history -> nav.navigate(R.id.walletHistory)
+            R.id.nav_pending_operations -> nav.navigate(R.id.nav_pending_operations)
+        }
+        drawer_layout.closeDrawer(START)
+        return true
+    }
+
+    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
+        super.onActivityResult(requestCode, resultCode, data)
+        if (requestCode == IntentIntegrator.REQUEST_CODE) {
+            parseActivityResult(requestCode, resultCode, data)?.contents?.let { contents ->
+                handleTalerUri(contents, "QR code")
+            }
+        }
+    }
+
+    override fun onDestroy() {
+        unregisterReceiver(triggerPaymentReceiver)
+        unregisterReceiver(nfcConnectedReceiver)
+        unregisterReceiver(nfcDisconnectedReceiver)
+        unregisterReceiver(tunnelResponseReceiver)
+        super.onDestroy()
+    }
+
+    private fun handleTalerUri(url: String, from: String) {
+        when {
+            url.toLowerCase(ROOT).startsWith("taler://pay/") -> {
+                Log.v(TAG, "navigating!")
+                nav.navigate(R.id.action_showBalance_to_promptPayment)
+                model.paymentManager.preparePay(url)
+            }
+            url.toLowerCase(ROOT).startsWith("taler://withdraw/") -> {
+                Log.v(TAG, "navigating!")
+                nav.navigate(R.id.action_showBalance_to_promptWithdraw)
+                model.withdrawManager.getWithdrawalInfo(url)
+            }
+            url.toLowerCase(ROOT).startsWith("taler://refund/") -> {
+                // TODO implement refunds
+                Snackbar.make(nav_view, "Refunds are not yet implemented", LENGTH_SHORT).show()
+            }
+            else -> {
+                Snackbar.make(
+                    nav_view,
+                    "URL from $from doesn't contain a supported Taler Uri.",
+                    LENGTH_SHORT
+                ).show()
+            }
+        }
+    }
+
+    private val triggerPaymentReceiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context, intent: Intent) {
+            if (nav.currentDestination?.id == R.id.promptPayment) return
+            intent.extras?.getString("contractUrl")?.let { url ->
+                nav.navigate(R.id.action_global_promptPayment)
+                model.paymentManager.preparePay(url)
+            }
+        }
+    }
+
+    private val nfcConnectedReceiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context, intent: Intent) {
+            Log.v(TAG, "got MERCHANT_NFC_CONNECTED")
+            //model.startTunnel()
+        }
+    }
+
+    private val nfcDisconnectedReceiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context, intent: Intent) {
+            Log.v(TAG, "got MERCHANT_NFC_DISCONNECTED")
+            //model.stopTunnel()
+        }
+    }
+
+    private val tunnelResponseReceiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context, intent: Intent) {
+            Log.v("taler-tunnel", "got HTTP_TUNNEL_RESPONSE")
+            intent.getStringExtra("response")?.let {
+                model.tunnelResponse(it)
+            }
+        }
+    }
+
+    override fun onResetConfirmed() {
+        model.dangerouslyReset()
+        Snackbar.make(nav_view, "Wallet has been reset", LENGTH_SHORT).show()
+    }
+
+    override fun onResetCancelled() {
+        Snackbar.make(nav_view, "Reset cancelled", LENGTH_SHORT).show()
+    }
+
+}
diff --git a/wallet/src/main/java/net/taler/wallet/Settings.kt b/wallet/src/main/java/net/taler/wallet/Settings.kt
new file mode 100644
index 0000000..6d10412
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/Settings.kt
@@ -0,0 +1,140 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+package net.taler.wallet
+
+import android.app.Dialog
+import android.content.Context
+import android.content.Intent
+import android.content.Intent.ACTION_CREATE_DOCUMENT
+import android.content.Intent.ACTION_OPEN_DOCUMENT
+import android.content.Intent.CATEGORY_OPENABLE
+import android.content.Intent.EXTRA_TITLE
+import android.os.Bundle
+import android.util.Log
+import android.view.LayoutInflater
+import android.view.View
+import android.view.View.GONE
+import android.view.View.VISIBLE
+import android.view.ViewGroup
+import androidx.appcompat.app.AlertDialog
+import androidx.fragment.app.DialogFragment
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.activityViewModels
+import androidx.lifecycle.Observer
+import kotlinx.android.synthetic.main.fragment_settings.*
+
+
+interface ResetDialogEventListener {
+    fun onResetConfirmed()
+    fun onResetCancelled()
+}
+
+
+class ResetDialogFragment : DialogFragment() {
+    private lateinit var listener: ResetDialogEventListener
+
+    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+        return activity?.let {
+            // Use the Builder class for convenient dialog construction
+            val builder = AlertDialog.Builder(it)
+            builder.setMessage("Do you really want to reset the wallet and lose all coins and purchases?  Consider making a backup first.")
+                .setPositiveButton("Reset") { _, _ ->
+                    listener.onResetConfirmed()
+                }
+                .setNegativeButton("Cancel") { _, _ ->
+                    listener.onResetCancelled()
+                }
+            // Create the AlertDialog object and return it
+            builder.create()
+        } ?: throw IllegalStateException("Activity cannot be null")
+    }
+
+    override fun onAttach(context: Context) {
+        super.onAttach(context)
+        // Verify that the host activity implements the callback interface
+        try {
+            // Instantiate the NoticeDialogListener so we can send events to the host
+            listener = context as ResetDialogEventListener
+        } catch (e: ClassCastException) {
+            // The activity doesn't implement the interface, throw exception
+            throw ClassCastException((context.toString() +
+                    " must implement ResetDialogEventListener"))
+        }
+    }
+}
+
+class Settings : Fragment() {
+
+    companion object {
+        private const val TAG = "taler-wallet"
+        private const val CREATE_FILE = 1
+        private const val PICK_FILE = 2
+    }
+
+    private val model: WalletViewModel by activityViewModels()
+
+    override fun onCreateView(
+        inflater: LayoutInflater, container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View? {
+        return inflater.inflate(R.layout.fragment_settings, container, false)
+    }
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        model.devMode.observe(viewLifecycleOwner, Observer { enabled ->
+            val visibility = if (enabled) VISIBLE else GONE
+            devSettingsTitle.visibility = visibility
+            button_reset_wallet_dangerously.visibility = visibility
+        })
+
+        textView4.text = BuildConfig.VERSION_NAME
+        button_reset_wallet_dangerously.setOnClickListener {
+            val d = ResetDialogFragment()
+            d.show(parentFragmentManager, "walletResetDialog")
+        }
+        button_backup_export.setOnClickListener {
+            val intent = Intent(ACTION_CREATE_DOCUMENT).apply {
+                addCategory(CATEGORY_OPENABLE)
+                type = "application/json"
+                putExtra(EXTRA_TITLE, "taler-wallet-backup.json")
+
+                // Optionally, specify a URI for the directory that should be opened in
+                // the system file picker before your app creates the document.
+                //putExtra(DocumentsContract.EXTRA_INITIAL_URI, pickerInitialUri)
+            }
+            startActivityForResult(intent, CREATE_FILE)
+        }
+        button_backup_import.setOnClickListener {
+            val intent = Intent(ACTION_OPEN_DOCUMENT).apply {
+                addCategory(CATEGORY_OPENABLE)
+                type = "application/json"
+
+                //putExtra(DocumentsContract.EXTRA_INITIAL_URI, pickerInitialUri)
+            }
+            startActivityForResult(intent, PICK_FILE)
+        }
+    }
+
+    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
+        if (data == null) return
+        when (requestCode) {
+            CREATE_FILE -> Log.i(TAG, "got createFile result with URL ${data.data}")
+            PICK_FILE -> Log.i(TAG, "got pickFile result with URL ${data.data}")
+        }
+    }
+
+}
diff --git a/wallet/src/main/java/net/taler/wallet/Utils.kt b/wallet/src/main/java/net/taler/wallet/Utils.kt
new file mode 100644
index 0000000..fb0b3ae
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/Utils.kt
@@ -0,0 +1,40 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+package net.taler.wallet
+
+import android.view.View
+import android.view.View.INVISIBLE
+import android.view.View.VISIBLE
+
+fun View.fadeIn(endAction: () -> Unit = {}) {
+    if (visibility == VISIBLE) return
+    alpha = 0f
+    visibility = VISIBLE
+    animate().alpha(1f).withEndAction {
+        if (context != null) endAction.invoke()
+    }.start()
+}
+
+fun View.fadeOut(endAction: () -> Unit = {}) {
+    if (visibility == INVISIBLE) return
+    animate().alpha(0f).withEndAction {
+        if (context == null) return@withEndAction
+        visibility = INVISIBLE
+        alpha = 1f
+        endAction.invoke()
+    }.start()
+}
diff --git a/wallet/src/main/java/net/taler/wallet/WalletViewModel.kt b/wallet/src/main/java/net/taler/wallet/WalletViewModel.kt
new file mode 100644
index 0000000..14a800f
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/WalletViewModel.kt
@@ -0,0 +1,124 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+package net.taler.wallet
+
+import android.app.Application
+import android.util.Log
+import androidx.annotation.UiThread
+import androidx.lifecycle.AndroidViewModel
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.MutableLiveData
+import androidx.lifecycle.distinctUntilChanged
+import com.fasterxml.jackson.databind.DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.module.kotlin.KotlinModule
+import net.taler.wallet.backend.WalletBackendApi
+import net.taler.wallet.history.HistoryManager
+import net.taler.wallet.payment.PaymentManager
+import net.taler.wallet.pending.PendingOperationsManager
+import net.taler.wallet.withdraw.WithdrawManager
+import org.json.JSONObject
+
+const val TAG = "taler-wallet"
+
+data class BalanceItem(val available: Amount, val pendingIncoming: Amount)
+
+class WalletViewModel(val app: Application) : AndroidViewModel(app) {
+
+    private val mBalances = MutableLiveData<List<BalanceItem>>()
+    val balances: LiveData<List<BalanceItem>> = mBalances.distinctUntilChanged()
+
+    val devMode = MutableLiveData(BuildConfig.DEBUG)
+    val showProgressBar = MutableLiveData<Boolean>()
+
+    private var activeGetBalance = 0
+
+    private val walletBackendApi = WalletBackendApi(app, {
+        activeGetBalance = 0
+        loadBalances()
+        pendingOperationsManager.getPending()
+    }) {
+        Log.i(TAG, "Received notification from wallet-core")
+        loadBalances()
+        pendingOperationsManager.getPending()
+    }
+
+    private val mapper = ObjectMapper()
+        .registerModule(KotlinModule())
+        .configure(FAIL_ON_UNKNOWN_PROPERTIES, false)
+
+    val withdrawManager = WithdrawManager(walletBackendApi)
+    val paymentManager = PaymentManager(walletBackendApi, mapper)
+    val pendingOperationsManager: PendingOperationsManager =
+        PendingOperationsManager(walletBackendApi)
+    val historyManager = HistoryManager(walletBackendApi, mapper)
+
+    override fun onCleared() {
+        walletBackendApi.destroy()
+        super.onCleared()
+    }
+
+    @UiThread
+    fun loadBalances() {
+        if (activeGetBalance > 0) {
+            return
+        }
+        activeGetBalance++
+        showProgressBar.value = true
+        walletBackendApi.sendRequest("getBalances", null) { isError, result ->
+            activeGetBalance--
+            if (isError) {
+                return@sendRequest
+            }
+            val balanceList = mutableListOf<BalanceItem>()
+            val byCurrency = result.getJSONObject("byCurrency")
+            val currencyList = byCurrency.keys().asSequence().toList().sorted()
+            for (currency in currencyList) {
+                val jsonAmount = byCurrency.getJSONObject(currency)
+                    .getJSONObject("available")
+                val amount = Amount.fromJson(jsonAmount)
+                val jsonAmountIncoming = byCurrency.getJSONObject(currency)
+                    .getJSONObject("pendingIncoming")
+                val amountIncoming = Amount.fromJson(jsonAmountIncoming)
+                balanceList.add(BalanceItem(amount, amountIncoming))
+            }
+            mBalances.postValue(balanceList)
+            showProgressBar.postValue(false)
+        }
+    }
+
+    @UiThread
+    fun dangerouslyReset() {
+        walletBackendApi.sendRequest("reset", null)
+        withdrawManager.testWithdrawalInProgress.value = false
+        mBalances.value = emptyList()
+    }
+
+    fun startTunnel() {
+        walletBackendApi.sendRequest("startTunnel", null)
+    }
+
+    fun stopTunnel() {
+        walletBackendApi.sendRequest("stopTunnel", null)
+    }
+
+    fun tunnelResponse(resp: String) {
+        val respJson = JSONObject(resp)
+        walletBackendApi.sendRequest("tunnelResponse", respJson)
+    }
+
+}
diff --git a/wallet/src/main/java/net/taler/wallet/backend/WalletBackendApi.kt b/wallet/src/main/java/net/taler/wallet/backend/WalletBackendApi.kt
new file mode 100644
index 0000000..d447287
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/backend/WalletBackendApi.kt
@@ -0,0 +1,141 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+
+package net.taler.wallet.backend
+
+import android.app.Application
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.ServiceConnection
+import android.os.Handler
+import android.os.IBinder
+import android.os.Message
+import android.os.Messenger
+import android.util.Log
+import android.util.SparseArray
+import org.json.JSONObject
+import java.lang.ref.WeakReference
+import java.util.*
+
+class WalletBackendApi(
+    private val app: Application,
+    private val onConnected: (() -> Unit),
+    private val notificationHandler: (() -> Unit)
+) {
+
+    private var walletBackendMessenger: Messenger? = null
+    private val queuedMessages = LinkedList<Message>()
+    private val handlers = SparseArray<(isError: Boolean, message: JSONObject) -> Unit>()
+    private var nextRequestID = 1
+
+    private val walletBackendConn = object : ServiceConnection {
+        override fun onServiceDisconnected(p0: ComponentName?) {
+            Log.w(TAG, "wallet backend service disconnected (crash?)")
+            walletBackendMessenger = null
+        }
+
+        override fun onServiceConnected(componentName: ComponentName?, binder: IBinder?) {
+            Log.i(TAG, "connected to wallet backend service")
+            val bm = Messenger(binder)
+            walletBackendMessenger = bm
+            pumpQueue(bm)
+            val msg = Message.obtain(null, WalletBackendService.MSG_SUBSCRIBE_NOTIFY)
+            msg.replyTo = incomingMessenger
+            bm.send(msg)
+            onConnected.invoke()
+        }
+    }
+
+    private class IncomingHandler(strongApi: WalletBackendApi) : Handler() {
+        private val weakApi = WeakReference(strongApi)
+        override fun handleMessage(msg: Message) {
+            val api = weakApi.get() ?: return
+            when (msg.what) {
+                WalletBackendService.MSG_REPLY -> {
+                    val requestID = msg.data.getInt("requestID", 0)
+                    val operation = msg.data.getString("operation", "??")
+                    Log.i(TAG, "got reply for operation $operation ($requestID)")
+                    val h = api.handlers.get(requestID)
+                    if (h == null) {
+                        Log.e(TAG, "request ID not associated with a handler")
+                        return
+                    }
+                    val response = msg.data.getString("response")
+                    if (response == null) {
+                        Log.e(TAG, "response did not contain response payload")
+                        return
+                    }
+                    val isError = msg.data.getBoolean("isError")
+                    val json = JSONObject(response)
+                    h(isError, json)
+                }
+                WalletBackendService.MSG_NOTIFY -> {
+                    api.notificationHandler.invoke()
+                }
+            }
+        }
+    }
+
+    private val incomingMessenger = Messenger(IncomingHandler(this))
+
+    init {
+        Intent(app, WalletBackendService::class.java).also { intent ->
+            app.bindService(intent, walletBackendConn, Context.BIND_AUTO_CREATE)
+        }
+    }
+
+    private fun pumpQueue(bm: Messenger) {
+        while (true) {
+            val msg = queuedMessages.pollFirst() ?: return
+            bm.send(msg)
+        }
+    }
+
+
+    fun sendRequest(
+        operation: String,
+        args: JSONObject?,
+        onResponse: (isError: Boolean, message: JSONObject) -> Unit = { _, _ -> }
+    ) {
+        val requestID = nextRequestID++
+        Log.i(TAG, "sending request for operation $operation ($requestID)")
+        val msg = Message.obtain(null, WalletBackendService.MSG_COMMAND)
+        handlers.put(requestID, onResponse)
+        msg.replyTo = incomingMessenger
+        val data = msg.data
+        data.putString("operation", operation)
+        data.putInt("requestID", requestID)
+        if (args != null) {
+            data.putString("args", args.toString())
+        }
+        val bm = walletBackendMessenger
+        if (bm != null) {
+            bm.send(msg)
+        } else {
+            queuedMessages.add(msg)
+        }
+    }
+
+    fun destroy() {
+        // FIXME: implement this!
+    }
+
+    companion object {
+        const val TAG = "WalletBackendApi"
+    }
+}
diff --git a/wallet/src/main/java/net/taler/wallet/backend/WalletBackendService.kt b/wallet/src/main/java/net/taler/wallet/backend/WalletBackendService.kt
new file mode 100644
index 0000000..0b71774
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/backend/WalletBackendService.kt
@@ -0,0 +1,239 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+
+package net.taler.wallet.backend
+
+import akono.AkonoJni
+import android.app.Service
+import android.content.Intent
+import android.os.Handler
+import android.os.IBinder
+import android.os.Message
+import android.os.Messenger
+import android.os.RemoteException
+import android.util.Log
+import net.taler.wallet.HostCardEmulatorService
+import org.json.JSONObject
+import java.lang.ref.WeakReference
+import java.util.*
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.system.exitProcess
+
+private const val TAG = "taler-wallet-backend"
+
+class RequestData(val clientRequestID: Int, val messenger: Messenger)
+
+
+class WalletBackendService : Service() {
+    /**
+     * Target we publish for clients to send messages to IncomingHandler.
+     */
+    private val messenger: Messenger = Messenger(IncomingHandler(this))
+
+    private lateinit var akono: AkonoJni
+
+    private var initialized = false
+
+    private var nextRequestID = 1
+
+    private val requests = ConcurrentHashMap<Int, RequestData>()
+
+    private val subscribers = LinkedList<Messenger>()
+
+    override fun onCreate() {
+        val talerWalletAndroidCode = assets.open("taler-wallet-android.js").use {
+            it.readBytes().toString(Charsets.UTF_8)
+        }
+
+
+        Log.i(TAG, "onCreate in wallet backend service")
+        akono = AkonoJni()
+        akono.putModuleCode("taler-wallet-android", talerWalletAndroidCode)
+        akono.setMessageHandler(object : AkonoJni.MessageHandler {
+            override fun handleMessage(message: String) {
+                this@WalletBackendService.handleAkonoMessage(message)
+            }
+        })
+        akono.evalNodeCode("console.log('hello world from taler wallet-android')")
+        //akono.evalNodeCode("require('source-map-support').install();")
+        akono.evalNodeCode("require('akono');")
+        akono.evalNodeCode("tw = require('taler-wallet-android');")
+        akono.evalNodeCode("tw.installAndroidWalletListener();")
+        sendInitMessage()
+        initialized = true
+        super.onCreate()
+    }
+
+    private fun sendInitMessage() {
+        val msg = JSONObject()
+        msg.put("operation", "init")
+        val args = JSONObject()
+        msg.put("args", args)
+        args.put("persistentStoragePath", "${application.filesDir}/talerwalletdb-v30.json")
+        akono.sendMessage(msg.toString())
+    }
+
+    /**
+     * Handler of incoming messages from clients.
+     */
+    class IncomingHandler(
+        service: WalletBackendService
+    ) : Handler() {
+
+        private val serviceWeakRef = WeakReference(service)
+
+        override fun handleMessage(msg: Message) {
+            val svc = serviceWeakRef.get() ?: return
+            when (msg.what) {
+                MSG_COMMAND -> {
+                    val data = msg.data
+                    val serviceRequestID = svc.nextRequestID++
+                    val clientRequestID = data.getInt("requestID", 0)
+                    if (clientRequestID == 0) {
+                        Log.e(TAG, "client requestID missing")
+                        return
+                    }
+                    val args = data.getString("args")
+                    val argsObj = if (args == null) {
+                        JSONObject()
+                    } else {
+                        JSONObject(args)
+                    }
+                    val operation = data.getString("operation", "")
+                    if (operation == "") {
+                        Log.e(TAG, "client command missing")
+                        return
+                    }
+                    Log.i(TAG, "got request for operation $operation")
+                    val request = JSONObject()
+                    request.put("operation", operation)
+                    request.put("id", serviceRequestID)
+                    request.put("args", argsObj)
+                    svc.akono.sendMessage(request.toString(2))
+                    Log.i(
+                        TAG,
+                        "mapping service request ID $serviceRequestID to client request ID $clientRequestID"
+                    )
+                    svc.requests[serviceRequestID] = RequestData(clientRequestID, msg.replyTo)
+                }
+                MSG_SUBSCRIBE_NOTIFY -> {
+                    Log.i(TAG, "subscribing client")
+                    val r = msg.replyTo
+                    if (r == null) {
+                        Log.e(
+                            TAG,
+                            "subscriber did not specify replyTo object in MSG_SUBSCRIBE_NOTIFY"
+                        )
+                    } else {
+                        svc.subscribers.add(msg.replyTo)
+                    }
+                }
+                MSG_UNSUBSCRIBE_NOTIFY -> {
+                    Log.i(TAG, "unsubscribing client")
+                    svc.subscribers.remove(msg.replyTo)
+                }
+                else -> {
+                    Log.e(TAG, "unknown message from client")
+                    super.handleMessage(msg)
+                }
+            }
+        }
+    }
+
+    override fun onBind(p0: Intent?): IBinder? {
+        return messenger.binder
+    }
+
+    private fun sendNotify() {
+        var rm: LinkedList<Messenger>? = null
+        for (s in subscribers) {
+            val m = Message.obtain(null, MSG_NOTIFY)
+            try {
+                s.send(m)
+            } catch (e: RemoteException) {
+                if (rm == null) {
+                    rm = LinkedList()
+                }
+                rm.add(s)
+                subscribers.remove(s)
+            }
+        }
+        if (rm != null) {
+            for (s in rm) {
+                subscribers.remove(s)
+            }
+        }
+    }
+
+    private fun handleAkonoMessage(messageStr: String) {
+        Log.v(TAG, "got back message: $messageStr")
+        val message = JSONObject(messageStr)
+        when (message.getString("type")) {
+            "notification" -> {
+                sendNotify()
+            }
+            "tunnelHttp" -> {
+                Log.v(TAG, "got http tunnel request!")
+                Intent().also { intent ->
+                    intent.action = HostCardEmulatorService.HTTP_TUNNEL_REQUEST
+                    intent.putExtra("tunnelMessage", messageStr)
+                    application.sendBroadcast(intent)
+                }
+            }
+            "response" -> {
+                when (val operation = message.getString("operation")) {
+                    "init" -> {
+                        Log.v(TAG, "got response for init operation")
+                        sendNotify()
+                    }
+                    "reset" -> {
+                        exitProcess(1)
+                    }
+                    else -> {
+                        val id = message.getInt("id")
+                        Log.v(TAG, "got response for operation $operation")
+                        val rd = requests[id]
+                        if (rd == null) {
+                            Log.e(TAG, "wallet returned unknown request ID ($id)")
+                            return
+                        }
+                        val m = Message.obtain(null, MSG_REPLY)
+                        val b = m.data
+                        if (message.has("result")) {
+                            val respJson = message.getJSONObject("result")
+                            b.putString("response", respJson.toString(2))
+                        } else {
+                            b.putString("response", "{}")
+                        }
+                        b.putBoolean("isError", message.getBoolean("isError"))
+                        b.putInt("requestID", rd.clientRequestID)
+                        b.putString("operation", operation)
+                        rd.messenger.send(m)
+                    }
+                }
+            }
+        }
+    }
+
+    companion object {
+        const val MSG_SUBSCRIBE_NOTIFY = 1
+        const val MSG_UNSUBSCRIBE_NOTIFY = 2
+        const val MSG_COMMAND = 3
+        const val MSG_REPLY = 4
+        const val MSG_NOTIFY = 5
+    }
+}
diff --git a/wallet/src/main/java/net/taler/wallet/crypto/Encoding.kt b/wallet/src/main/java/net/taler/wallet/crypto/Encoding.kt
new file mode 100644
index 0000000..25a59be
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/crypto/Encoding.kt
@@ -0,0 +1,134 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+package net.taler.wallet.crypto
+
+import java.io.ByteArrayOutputStream
+
+class EncodingException : Exception("Invalid encoding")
+
+
+object Base32Crockford {
+
+    private fun ByteArray.getIntAt(index: Int): Int {
+        val x = this[index].toInt()
+        return if (x >= 0) x else (x + 256)
+    }
+
+    private var encTable = "0123456789ABCDEFGHJKMNPQRSTVWXYZ"
+
+    fun encode(data: ByteArray): String {
+        val sb = StringBuilder()
+        val size = data.size
+        var bitBuf = 0
+        var numBits = 0
+        var pos = 0
+        while (pos < size || numBits > 0) {
+            if (pos < size && numBits < 5) {
+                val d = data.getIntAt(pos++)
+                bitBuf = (bitBuf shl 8) or d
+                numBits += 8
+            }
+            if (numBits < 5) {
+                // zero-padding
+                bitBuf = bitBuf shl (5 - numBits)
+                numBits = 5
+            }
+            val v = bitBuf.ushr(numBits - 5) and 31
+            sb.append(encTable[v])
+            numBits -= 5
+        }
+        return sb.toString()
+    }
+
+    fun decode(encoded: String, out: ByteArrayOutputStream) {
+        val size = encoded.length
+        var bitpos = 0
+        var bitbuf = 0
+        var readPosition = 0
+
+        while (readPosition < size || bitpos > 0) {
+            //println("at position $readPosition with bitpos $bitpos")
+            if (readPosition < size) {
+                val v = getValue(encoded[readPosition++])
+                bitbuf = (bitbuf shl 5) or v
+                bitpos += 5
+            }
+            while (bitpos >= 8) {
+                val d = (bitbuf ushr (bitpos - 8)) and 0xFF
+                out.write(d)
+                bitpos -= 8
+            }
+            if (readPosition == size && bitpos > 0) {
+                bitbuf = (bitbuf shl (8 - bitpos)) and 0xFF
+                bitpos = if (bitbuf == 0) 0 else 8
+            }
+        }
+    }
+
+    fun decode(encoded: String): ByteArray {
+        val out = ByteArrayOutputStream()
+        decode(encoded, out)
+        return out.toByteArray()
+    }
+
+    private fun getValue(chr: Char): Int {
+        var a = chr
+        when (a) {
+            'O', 'o' -> a = '0'
+            'i', 'I', 'l', 'L' -> a = '1'
+            'u', 'U' -> a = 'V'
+        }
+        if (a in '0'..'9')
+            return a - '0'
+        if (a in 'a'..'z')
+            a = Character.toUpperCase(a)
+        var dec = 0
+        if (a in 'A'..'Z') {
+            if ('I' < a) dec++
+            if ('L' < a) dec++
+            if ('O' < a) dec++
+            if ('U' < a) dec++
+            return a - 'A' + 10 - dec
+        }
+        throw EncodingException()
+    }
+
+    /**
+     * Compute the length of the resulting string when encoding data of the given size
+     * in bytes.
+     *
+     * @param dataSize size of the data to encode in bytes
+     * @return size of the string that would result from encoding
+     */
+    @Suppress("unused")
+    fun calculateEncodedStringLength(dataSize: Int): Int {
+        return (dataSize * 8 + 4) / 5
+    }
+
+    /**
+     * Compute the length of the resulting data in bytes when decoding a (valid) string of the
+     * given size.
+     *
+     * @param stringSize size of the string to decode
+     * @return size of the resulting data in bytes
+     */
+    @Suppress("unused")
+    fun calculateDecodedDataLength(stringSize: Int): Int {
+        return stringSize * 5 / 8
+    }
+}
+
diff --git a/wallet/src/main/java/net/taler/wallet/history/HistoryEvent.kt b/wallet/src/main/java/net/taler/wallet/history/HistoryEvent.kt
new file mode 100644
index 0000000..9e5c99d
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/history/HistoryEvent.kt
@@ -0,0 +1,452 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+package net.taler.wallet.history
+
+import androidx.annotation.DrawableRes
+import androidx.annotation.LayoutRes
+import androidx.annotation.StringRes
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties
+import com.fasterxml.jackson.annotation.JsonInclude
+import com.fasterxml.jackson.annotation.JsonInclude.Include.NON_EMPTY
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.fasterxml.jackson.annotation.JsonSubTypes
+import com.fasterxml.jackson.annotation.JsonSubTypes.Type
+import com.fasterxml.jackson.annotation.JsonTypeInfo
+import com.fasterxml.jackson.annotation.JsonTypeInfo.As.PROPERTY
+import com.fasterxml.jackson.annotation.JsonTypeInfo.Id.NAME
+import com.fasterxml.jackson.annotation.JsonTypeName
+import net.taler.wallet.ParsedAmount.Companion.parseAmount
+import net.taler.wallet.R
+import org.json.JSONObject
+
+enum class ReserveType {
+    /**
+     * Manually created.
+     */
+    @JsonProperty("manual")
+    MANUAL,
+    /**
+     * Withdrawn from a bank that has "tight" Taler integration
+     */
+    @JsonProperty("taler-bank-withdraw")
+    @Suppress("unused")
+    TALER_BANK_WITHDRAW,
+}
+
+@JsonInclude(NON_EMPTY)
+class ReserveCreationDetail(val type: ReserveType, val bankUrl: String?)
+
+enum class RefreshReason {
+    @JsonProperty("manual")
+    @Suppress("unused")
+    MANUAL,
+    @JsonProperty("pay")
+    PAY,
+    @JsonProperty("refund")
+    @Suppress("unused")
+    REFUND,
+    @JsonProperty("abort-pay")
+    @Suppress("unused")
+    ABORT_PAY,
+    @JsonProperty("recoup")
+    @Suppress("unused")
+    RECOUP,
+    @JsonProperty("backup-restored")
+    @Suppress("unused")
+    BACKUP_RESTORED
+}
+
+
+@JsonInclude(NON_EMPTY)
+class Timestamp(
+    @JsonProperty("t_ms")
+    val ms: Long
+)
+
+@JsonInclude(NON_EMPTY)
+class ReserveShortInfo(
+    /**
+     * The exchange that the reserve will be at.
+     */
+    val exchangeBaseUrl: String,
+    /**
+     * Key to query more details
+     */
+    val reservePub: String,
+    /**
+     * Detail about how the reserve has been created.
+     */
+    val reserveCreationDetail: ReserveCreationDetail
+)
+
+typealias History = ArrayList<HistoryEvent>
+
+@JsonTypeInfo(
+    use = NAME,
+    include = PROPERTY,
+    property = "type",
+    defaultImpl = HistoryUnknownEvent::class
+)
+/** missing:
+AuditorComplaintSent = "auditor-complained-sent",
+AuditorComplaintProcessed = "auditor-complaint-processed",
+AuditorTrustAdded = "auditor-trust-added",
+AuditorTrustRemoved = "auditor-trust-removed",
+ExchangeTermsAccepted = "exchange-terms-accepted",
+ExchangePolicyChanged = "exchange-policy-changed",
+ExchangeTrustAdded = "exchange-trust-added",
+ExchangeTrustRemoved = "exchange-trust-removed",
+FundsDepositedToSelf = "funds-deposited-to-self",
+FundsRecouped = "funds-recouped",
+ReserveCreated = "reserve-created",
+ */
+@JsonSubTypes(
+    Type(value = ExchangeAddedEvent::class, name = "exchange-added"),
+    Type(value = ExchangeUpdatedEvent::class, name = "exchange-updated"),
+    Type(value = ReserveBalanceUpdatedEvent::class, name = "reserve-balance-updated"),
+    Type(value = HistoryWithdrawnEvent::class, name = "withdrawn"),
+    Type(value = HistoryOrderAcceptedEvent::class, name = "order-accepted"),
+    Type(value = HistoryOrderRefusedEvent::class, name = "order-refused"),
+    Type(value = HistoryOrderRedirectedEvent::class, name = "order-redirected"),
+    Type(value = HistoryPaymentSentEvent::class, name = "payment-sent"),
+    Type(value = HistoryPaymentAbortedEvent::class, name = "payment-aborted"),
+    Type(value = HistoryTipAcceptedEvent::class, name = "tip-accepted"),
+    Type(value = HistoryTipDeclinedEvent::class, name = "tip-declined"),
+    Type(value = HistoryRefundedEvent::class, name = "refund"),
+    Type(value = HistoryRefreshedEvent::class, name = "refreshed")
+)
+@JsonIgnoreProperties(
+    value = [
+        "eventId"
+    ]
+)
+abstract class HistoryEvent(
+    val timestamp: Timestamp,
+    @get:LayoutRes
+    open val layout: Int = R.layout.history_row,
+    @get:StringRes
+    open val title: Int = 0,
+    @get:DrawableRes
+    open val icon: Int = R.drawable.ic_account_balance,
+    open val showToUser: Boolean = false
+) {
+    open lateinit var json: JSONObject
+}
+
+
+class HistoryUnknownEvent(timestamp: Timestamp) : HistoryEvent(timestamp) {
+    override val title = R.string.history_event_unknown
+}
+
+@JsonTypeName("exchange-added")
+class ExchangeAddedEvent(
+    timestamp: Timestamp,
+    val exchangeBaseUrl: String,
+    val builtIn: Boolean
+) : HistoryEvent(timestamp) {
+    override val title = R.string.history_event_exchange_added
+}
+
+@JsonTypeName("exchange-updated")
+class ExchangeUpdatedEvent(
+    timestamp: Timestamp,
+    val exchangeBaseUrl: String
+) : HistoryEvent(timestamp) {
+    override val title = R.string.history_event_exchange_updated
+}
+
+
+@JsonTypeName("reserve-balance-updated")
+class ReserveBalanceUpdatedEvent(
+    timestamp: Timestamp,
+    val newHistoryTransactions: List<ReserveTransaction>,
+    /**
+     * Condensed information about the reserve.
+     */
+    val reserveShortInfo: ReserveShortInfo,
+    /**
+     * Amount currently left in the reserve.
+     */
+    val amountReserveBalance: String,
+    /**
+     * Amount we expected to be in the reserve at that time,
+     * considering ongoing withdrawals from that reserve.
+     */
+    val amountExpected: String
+) : HistoryEvent(timestamp) {
+    override val title = R.string.history_event_reserve_balance_updated
+}
+
+@JsonTypeName("withdrawn")
+class HistoryWithdrawnEvent(
+    timestamp: Timestamp,
+    /**
+     * Exchange that was withdrawn from.
+     */
+    val exchangeBaseUrl: String,
+    /**
+     * Unique identifier for the withdrawal session, can be used to
+     * query more detailed information from the wallet.
+     */
+    val withdrawSessionId: String,
+    val withdrawalSource: WithdrawalSource,
+    /**
+     * Amount that has been subtracted from the reserve's balance
+     * for this withdrawal.
+     */
+    val amountWithdrawnRaw: String,
+    /**
+     * Amount that actually was added to the wallet's balance.
+     */
+    val amountWithdrawnEffective: String
+) : HistoryEvent(timestamp) {
+    override val layout = R.layout.history_receive
+    override val title = R.string.history_event_withdrawn
+    override val icon = R.drawable.history_withdrawn
+    override val showToUser = true
+}
+
+@JsonTypeName("order-accepted")
+class HistoryOrderAcceptedEvent(
+    timestamp: Timestamp,
+    /**
+     * Condensed info about the order.
+     */
+    val orderShortInfo: OrderShortInfo
+) : HistoryEvent(timestamp) {
+    override val icon = R.drawable.ic_add_circle
+    override val title = R.string.history_event_order_accepted
+}
+
+@JsonTypeName("order-refused")
+class HistoryOrderRefusedEvent(
+    timestamp: Timestamp,
+    /**
+     * Condensed info about the order.
+     */
+    val orderShortInfo: OrderShortInfo
+) : HistoryEvent(timestamp) {
+    override val icon = R.drawable.ic_cancel
+    override val title = R.string.history_event_order_refused
+}
+
+@JsonTypeName("payment-sent")
+class HistoryPaymentSentEvent(
+    timestamp: Timestamp,
+    /**
+     * Condensed info about the order that we already paid for.
+     */
+    val orderShortInfo: OrderShortInfo,
+    /**
+     * Set to true if the payment has been previously sent
+     * to the merchant successfully, possibly with a different session ID.
+     */
+    val replay: Boolean,
+    /**
+     * Number of coins that were involved in the payment.
+     */
+    val numCoins: Int,
+    /**
+     * Amount that was paid, including deposit and wire fees.
+     */
+    val amountPaidWithFees: String,
+    /**
+     * Session ID that the payment was (re-)submitted under.
+     */
+    val sessionId: String?
+) : HistoryEvent(timestamp) {
+    override val layout = R.layout.history_payment
+    override val title = R.string.history_event_payment_sent
+    override val icon = R.drawable.ic_cash_usd_outline
+    override val showToUser = true
+}
+
+@JsonTypeName("payment-aborted")
+class HistoryPaymentAbortedEvent(
+    timestamp: Timestamp,
+    /**
+     * Condensed info about the order that we already paid for.
+     */
+    val orderShortInfo: OrderShortInfo,
+    /**
+     * Amount that was lost due to refund and refreshing fees.
+     */
+    val amountLost: String
+) : HistoryEvent(timestamp) {
+    override val layout = R.layout.history_payment
+    override val title = R.string.history_event_payment_aborted
+    override val icon = R.drawable.history_payment_aborted
+    override val showToUser = true
+}
+
+@JsonTypeName("refreshed")
+class HistoryRefreshedEvent(
+    timestamp: Timestamp,
+    /**
+     * Amount that is now available again because it has
+     * been refreshed.
+     */
+    val amountRefreshedEffective: String,
+    /**
+     * Amount that we spent for refreshing.
+     */
+    val amountRefreshedRaw: String,
+    /**
+     * Why was the refreshing done?
+     */
+    val refreshReason: RefreshReason,
+    val numInputCoins: Int,
+    val numRefreshedInputCoins: Int,
+    val numOutputCoins: Int,
+    /**
+     * Identifier for a refresh group, contains one or
+     * more refresh session IDs.
+     */
+    val refreshGroupId: String
+) : HistoryEvent(timestamp) {
+    override val layout = R.layout.history_payment
+    override val icon = R.drawable.history_refresh
+    override val title = R.string.history_event_refreshed
+    override val showToUser =
+        !(parseAmount(amountRefreshedRaw) - parseAmount(amountRefreshedEffective)).isZero()
+}
+
+@JsonTypeName("order-redirected")
+class HistoryOrderRedirectedEvent(
+    timestamp: Timestamp,
+    /**
+     * Condensed info about the new order that contains a
+     * product (identified by the fulfillment URL) that we've already paid for.
+     */
+    val newOrderShortInfo: OrderShortInfo,
+    /**
+     * Condensed info about the order that we already paid for.
+     */
+    val alreadyPaidOrderShortInfo: OrderShortInfo
+) : HistoryEvent(timestamp) {
+    override val icon = R.drawable.ic_directions
+    override val title = R.string.history_event_order_redirected
+}
+
+@JsonTypeName("tip-accepted")
+class HistoryTipAcceptedEvent(
+    timestamp: Timestamp,
+    /**
+     * Unique identifier for the tip to query more information.
+     */
+    val tipId: String,
+    /**
+     * Raw amount of the tip, without extra fees that apply.
+     */
+    val tipRaw: String
+) : HistoryEvent(timestamp) {
+    override val icon = R.drawable.history_tip_accepted
+    override val title = R.string.history_event_tip_accepted
+    override val layout = R.layout.history_receive
+    override val showToUser = true
+}
+
+@JsonTypeName("tip-declined")
+class HistoryTipDeclinedEvent(
+    timestamp: Timestamp,
+    /**
+     * Unique identifier for the tip to query more information.
+     */
+    val tipId: String,
+    /**
+     * Raw amount of the tip, without extra fees that apply.
+     */
+    val tipAmount: String
+) : HistoryEvent(timestamp) {
+    override val icon = R.drawable.history_tip_declined
+    override val title = R.string.history_event_tip_declined
+    override val layout = R.layout.history_receive
+    override val showToUser = true
+}
+
+@JsonTypeName("refund")
+class HistoryRefundedEvent(
+    timestamp: Timestamp,
+    val orderShortInfo: OrderShortInfo,
+    /**
+     * Unique identifier for this refund.
+     * (Identifies multiple refund permissions that were obtained at once.)
+     */
+    val refundGroupId: String,
+    /**
+     * Part of the refund that couldn't be applied because
+     * the refund permissions were expired.
+     */
+    val amountRefundedInvalid: String,
+    /**
+     * Amount that has been refunded by the merchant.
+     */
+    val amountRefundedRaw: String,
+    /**
+     * Amount will be added to the wallet's balance after fees and refreshing.
+     */
+    val amountRefundedEffective: String
+) : HistoryEvent(timestamp) {
+    override val icon = R.drawable.history_refund
+    override val title = R.string.history_event_refund
+    override val layout = R.layout.history_receive
+    override val showToUser = true
+}
+
+@JsonTypeInfo(
+    use = NAME,
+    include = PROPERTY,
+    property = "type"
+)
+@JsonSubTypes(
+    Type(value = WithdrawalSourceReserve::class, name = "reserve")
+)
+abstract class WithdrawalSource
+
+@Suppress("unused")
+@JsonTypeName("tip")
+class WithdrawalSourceTip(
+    val tipId: String
+) : WithdrawalSource()
+
+@JsonTypeName("reserve")
+class WithdrawalSourceReserve(
+    val reservePub: String
+) : WithdrawalSource()
+
+data class OrderShortInfo(
+    /**
+     * Wallet-internal identifier of the proposal.
+     */
+    val proposalId: String,
+    /**
+     * Order ID, uniquely identifies the order within a merchant instance.
+     */
+    val orderId: String,
+    /**
+     * Base URL of the merchant.
+     */
+    val merchantBaseUrl: String,
+    /**
+     * Amount that must be paid for the contract.
+     */
+    val amount: String,
+    /**
+     * Summary of the proposal, given by the merchant.
+     */
+    val summary: String
+)
diff --git a/wallet/src/main/java/net/taler/wallet/history/HistoryManager.kt b/wallet/src/main/java/net/taler/wallet/history/HistoryManager.kt
new file mode 100644
index 0000000..c350daa
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/history/HistoryManager.kt
@@ -0,0 +1,71 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+package net.taler.wallet.history
+
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.MutableLiveData
+import androidx.lifecycle.asLiveData
+import androidx.lifecycle.switchMap
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.module.kotlin.readValue
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.flow.callbackFlow
+import kotlinx.coroutines.flow.onCompletion
+import kotlinx.coroutines.flow.onStart
+import net.taler.wallet.backend.WalletBackendApi
+
+@Suppress("EXPERIMENTAL_API_USAGE")
+class HistoryManager(
+    private val walletBackendApi: WalletBackendApi,
+    private val mapper: ObjectMapper
+) {
+
+    private val mProgress = MutableLiveData<Boolean>()
+    val progress: LiveData<Boolean> = mProgress
+
+    val showAll = MutableLiveData<Boolean>()
+
+    val history: LiveData<History> = showAll.switchMap { showAll ->
+        loadHistory(showAll)
+            .onStart { mProgress.postValue(true) }
+            .onCompletion { mProgress.postValue(false) }
+            .asLiveData(Dispatchers.IO)
+    }
+
+    private fun loadHistory(showAll: Boolean) = callbackFlow {
+        walletBackendApi.sendRequest("getHistory", null) { isError, result ->
+            if (isError) {
+                // TODO show error message in [WalletHistory] fragment
+                close()
+                return@sendRequest
+            }
+            val history = History()
+            val json = result.getJSONArray("history")
+            for (i in 0 until json.length()) {
+                val event: HistoryEvent = mapper.readValue(json.getString(i))
+                event.json = json.getJSONObject(i)
+                history.add(event)
+            }
+            history.reverse()  // show latest first
+            offer(if (showAll) history else history.filter { it.showToUser } as History)
+            close()
+        }
+        awaitClose()
+    }
+
+}
diff --git a/wallet/src/main/java/net/taler/wallet/history/JsonDialogFragment.kt b/wallet/src/main/java/net/taler/wallet/history/JsonDialogFragment.kt
new file mode 100644
index 0000000..f51dba9
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/history/JsonDialogFragment.kt
@@ -0,0 +1,50 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+package net.taler.wallet.history
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.fragment.app.DialogFragment
+import kotlinx.android.synthetic.main.fragment_json.*
+import net.taler.wallet.R
+
+class JsonDialogFragment : DialogFragment() {
+
+    companion object {
+        fun new(json: String): JsonDialogFragment {
+            return JsonDialogFragment().apply {
+                arguments = Bundle().apply { putString("json", json) }
+            }
+        }
+    }
+
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View? {
+        return inflater.inflate(R.layout.fragment_json, container, false)
+    }
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        val json = arguments!!.getString("json")
+        jsonView.text = json
+    }
+
+}
diff --git a/wallet/src/main/java/net/taler/wallet/history/ReserveTransaction.kt b/wallet/src/main/java/net/taler/wallet/history/ReserveTransaction.kt
new file mode 100644
index 0000000..45c539c
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/history/ReserveTransaction.kt
@@ -0,0 +1,58 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+package net.taler.wallet.history
+
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.fasterxml.jackson.annotation.JsonSubTypes
+import com.fasterxml.jackson.annotation.JsonTypeInfo
+import com.fasterxml.jackson.annotation.JsonTypeInfo.As.PROPERTY
+import com.fasterxml.jackson.annotation.JsonTypeInfo.Id.NAME
+import com.fasterxml.jackson.annotation.JsonTypeName
+
+
+@JsonTypeInfo(
+    use = NAME,
+    include = PROPERTY,
+    property = "type"
+)
+@JsonSubTypes(
+    JsonSubTypes.Type(value = ReserveDepositTransaction::class, name = "DEPOSIT")
+)
+abstract class ReserveTransaction
+
+
+@JsonTypeName("DEPOSIT")
+class ReserveDepositTransaction(
+    /**
+     * Amount withdrawn.
+     */
+    val amount: String,
+    /**
+     * Sender account payto://-URL
+     */
+    @JsonProperty("sender_account_url")
+    val senderAccountUrl: String,
+    /**
+     * Transfer details uniquely identifying the transfer.
+     */
+    @JsonProperty("wire_reference")
+    val wireReference: String,
+    /**
+     * Timestamp of the incoming wire transfer.
+     */
+    val timestamp: Timestamp
+) : ReserveTransaction()
diff --git a/wallet/src/main/java/net/taler/wallet/history/WalletHistoryAdapter.kt b/wallet/src/main/java/net/taler/wallet/history/WalletHistoryAdapter.kt
new file mode 100644
index 0000000..71bdebc
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/history/WalletHistoryAdapter.kt
@@ -0,0 +1,243 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+package net.taler.wallet.history
+
+import android.annotation.SuppressLint
+import android.graphics.Paint.STRIKE_THRU_TEXT_FLAG
+import android.text.format.DateUtils.DAY_IN_MILLIS
+import android.text.format.DateUtils.FORMAT_ABBREV_MONTH
+import android.text.format.DateUtils.FORMAT_ABBREV_RELATIVE
+import android.text.format.DateUtils.FORMAT_NO_YEAR
+import android.text.format.DateUtils.FORMAT_SHOW_DATE
+import android.text.format.DateUtils.FORMAT_SHOW_TIME
+import android.text.format.DateUtils.MINUTE_IN_MILLIS
+import android.text.format.DateUtils.formatDateTime
+import android.text.format.DateUtils.getRelativeTimeSpanString
+import android.view.LayoutInflater
+import android.view.View
+import android.view.View.GONE
+import android.view.View.VISIBLE
+import android.view.ViewGroup
+import android.widget.ImageView
+import android.widget.TextView
+import androidx.annotation.CallSuper
+import androidx.core.net.toUri
+import androidx.recyclerview.widget.RecyclerView.Adapter
+import androidx.recyclerview.widget.RecyclerView.ViewHolder
+import net.taler.wallet.BuildConfig
+import net.taler.wallet.ParsedAmount
+import net.taler.wallet.ParsedAmount.Companion.parseAmount
+import net.taler.wallet.R
+
+
+internal class WalletHistoryAdapter(
+    private val listener: OnEventClickListener,
+    private var history: History = History()
+) : Adapter<WalletHistoryAdapter.HistoryEventViewHolder>() {
+
+    init {
+        setHasStableIds(false)
+    }
+
+    override fun getItemViewType(position: Int): Int = history[position].layout
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): HistoryEventViewHolder {
+        val view = LayoutInflater.from(parent.context).inflate(viewType, parent, false)
+        return when (viewType) {
+            R.layout.history_receive -> HistoryReceiveViewHolder(view)
+            R.layout.history_payment -> HistoryPaymentViewHolder(view)
+            else -> GenericHistoryEventViewHolder(view)
+        }
+    }
+
+    override fun getItemCount(): Int = history.size
+
+    override fun onBindViewHolder(holder: HistoryEventViewHolder, position: Int) {
+        val event = history[position]
+        holder.bind(event)
+    }
+
+    fun update(updatedHistory: History) {
+        this.history = updatedHistory
+        this.notifyDataSetChanged()
+    }
+
+    internal abstract inner class HistoryEventViewHolder(protected val v: View) : ViewHolder(v) {
+
+        private val icon: ImageView = v.findViewById(R.id.icon)
+        protected val title: TextView = v.findViewById(R.id.title)
+        private val time: TextView = v.findViewById(R.id.time)
+
+        @CallSuper
+        open fun bind(event: HistoryEvent) {
+            if (BuildConfig.DEBUG) {  // doesn't produce recycling issues, no need to cover all cases
+                v.setOnClickListener { listener.onEventClicked(event) }
+            } else {
+                v.background = null
+            }
+            icon.setImageResource(event.icon)
+            if (event.title == 0) title.text = event::class.java.simpleName
+            else title.setText(event.title)
+            time.text = getRelativeTime(event.timestamp.ms)
+        }
+
+        private fun getRelativeTime(timestamp: Long): CharSequence {
+            val now = System.currentTimeMillis()
+            return if (now - timestamp > DAY_IN_MILLIS * 2) {
+                formatDateTime(
+                    v.context,
+                    timestamp,
+                    FORMAT_SHOW_TIME or FORMAT_SHOW_DATE or FORMAT_ABBREV_MONTH or FORMAT_NO_YEAR
+                )
+            } else {
+                getRelativeTimeSpanString(timestamp, now, MINUTE_IN_MILLIS, FORMAT_ABBREV_RELATIVE)
+            }
+        }
+
+    }
+
+    internal inner class GenericHistoryEventViewHolder(v: View) : HistoryEventViewHolder(v) {
+
+        private val info: TextView = v.findViewById(R.id.info)
+
+        override fun bind(event: HistoryEvent) {
+            super.bind(event)
+            info.text = when (event) {
+                is ExchangeAddedEvent -> event.exchangeBaseUrl
+                is ExchangeUpdatedEvent -> event.exchangeBaseUrl
+                is ReserveBalanceUpdatedEvent -> parseAmount(event.amountReserveBalance).toString()
+                is HistoryPaymentSentEvent -> event.orderShortInfo.summary
+                is HistoryOrderAcceptedEvent -> event.orderShortInfo.summary
+                is HistoryOrderRefusedEvent -> event.orderShortInfo.summary
+                is HistoryOrderRedirectedEvent -> event.newOrderShortInfo.summary
+                else -> ""
+            }
+        }
+
+    }
+
+    internal inner class HistoryReceiveViewHolder(v: View) : HistoryEventViewHolder(v) {
+
+        private val summary: TextView = v.findViewById(R.id.summary)
+        private val amountWithdrawn: TextView = v.findViewById(R.id.amountWithdrawn)
+        private val feeLabel: TextView = v.findViewById(R.id.feeLabel)
+        private val fee: TextView = v.findViewById(R.id.fee)
+
+        override fun bind(event: HistoryEvent) {
+            super.bind(event)
+            when (event) {
+                is HistoryWithdrawnEvent -> bind(event)
+                is HistoryRefundedEvent -> bind(event)
+                is HistoryTipAcceptedEvent -> bind(event)
+                is HistoryTipDeclinedEvent -> bind(event)
+            }
+        }
+
+        private fun bind(event: HistoryWithdrawnEvent) {
+            title.text = getHostname(event.exchangeBaseUrl)
+            summary.setText(event.title)
+
+            val parsedEffective = parseAmount(event.amountWithdrawnEffective)
+            val parsedRaw = parseAmount(event.amountWithdrawnRaw)
+            showAmounts(parsedEffective, parsedRaw)
+        }
+
+        private fun bind(event: HistoryRefundedEvent) {
+            title.text = event.orderShortInfo.summary
+            summary.setText(event.title)
+
+            val parsedEffective = parseAmount(event.amountRefundedEffective)
+            val parsedRaw = parseAmount(event.amountRefundedRaw)
+            showAmounts(parsedEffective, parsedRaw)
+        }
+
+        private fun bind(event: HistoryTipAcceptedEvent) {
+            title.setText(event.title)
+            summary.text = null
+            val amount = parseAmount(event.tipRaw)
+            showAmounts(amount, amount)
+        }
+
+        private fun bind(event: HistoryTipDeclinedEvent) {
+            title.setText(event.title)
+            summary.text = null
+            val amount = parseAmount(event.tipAmount)
+            showAmounts(amount, amount)
+            amountWithdrawn.paintFlags = amountWithdrawn.paintFlags or STRIKE_THRU_TEXT_FLAG
+        }
+
+        private fun showAmounts(effective: ParsedAmount, raw: ParsedAmount) {
+            @SuppressLint("SetTextI18n")
+            amountWithdrawn.text = "+$raw"
+            val calculatedFee = raw - effective
+            if (calculatedFee.isZero()) {
+                fee.visibility = GONE
+                feeLabel.visibility = GONE
+            } else {
+                @SuppressLint("SetTextI18n")
+                fee.text = "-$calculatedFee"
+                fee.visibility = VISIBLE
+                feeLabel.visibility = VISIBLE
+            }
+            amountWithdrawn.paintFlags = fee.paintFlags
+        }
+
+        private fun getHostname(url: String): String {
+            return url.toUri().host!!
+        }
+
+    }
+
+    internal inner class HistoryPaymentViewHolder(v: View) : HistoryEventViewHolder(v) {
+
+        private val summary: TextView = v.findViewById(R.id.summary)
+        private val amountPaidWithFees: TextView = v.findViewById(R.id.amountPaidWithFees)
+
+        override fun bind(event: HistoryEvent) {
+            super.bind(event)
+            summary.setText(event.title)
+            when (event) {
+                is HistoryPaymentSentEvent -> bind(event)
+                is HistoryPaymentAbortedEvent -> bind(event)
+                is HistoryRefreshedEvent -> bind(event)
+            }
+        }
+
+        private fun bind(event: HistoryPaymentSentEvent) {
+            title.text = event.orderShortInfo.summary
+            @SuppressLint("SetTextI18n")
+            amountPaidWithFees.text = "-${parseAmount(event.amountPaidWithFees)}"
+        }
+
+        private fun bind(event: HistoryPaymentAbortedEvent) {
+            title.text = event.orderShortInfo.summary
+            @SuppressLint("SetTextI18n")
+            amountPaidWithFees.text = "-${parseAmount(event.amountLost)}"
+        }
+
+        private fun bind(event: HistoryRefreshedEvent) {
+            title.text = ""
+            val fee =
+                parseAmount(event.amountRefreshedRaw) - parseAmount(event.amountRefreshedEffective)
+            @SuppressLint("SetTextI18n")
+            if (fee.isZero()) amountPaidWithFees.text = null
+            else amountPaidWithFees.text = "-$fee"
+        }
+
+    }
+
+}
diff --git a/wallet/src/main/java/net/taler/wallet/history/WalletHistoryFragment.kt b/wallet/src/main/java/net/taler/wallet/history/WalletHistoryFragment.kt
new file mode 100644
index 0000000..4f8ab82
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/history/WalletHistoryFragment.kt
@@ -0,0 +1,115 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+package net.taler.wallet.history
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.Menu
+import android.view.MenuInflater
+import android.view.MenuItem
+import android.view.View
+import android.view.View.INVISIBLE
+import android.view.View.VISIBLE
+import android.view.ViewGroup
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.activityViewModels
+import androidx.lifecycle.Observer
+import androidx.recyclerview.widget.DividerItemDecoration
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.LinearLayoutManager.VERTICAL
+import kotlinx.android.synthetic.main.fragment_show_balance.*
+import kotlinx.android.synthetic.main.fragment_show_history.*
+import net.taler.wallet.R
+import net.taler.wallet.WalletViewModel
+
+interface OnEventClickListener {
+    fun onEventClicked(event: HistoryEvent)
+}
+
+class WalletHistoryFragment : Fragment(), OnEventClickListener {
+
+    private val model: WalletViewModel by activityViewModels()
+    private val historyManager by lazy { model.historyManager }
+    private lateinit var showAllItem: MenuItem
+    private var reloadHistoryItem: MenuItem? = null
+    private val historyAdapter = WalletHistoryAdapter(this)
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setHasOptionsMenu(true)
+    }
+
+    override fun onCreateView(
+        inflater: LayoutInflater, container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View? {
+        return inflater.inflate(R.layout.fragment_show_history, container, false)
+    }
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        historyList.apply {
+            layoutManager = LinearLayoutManager(context)
+            adapter = historyAdapter
+            addItemDecoration(DividerItemDecoration(context, VERTICAL))
+        }
+
+        model.devMode.observe(viewLifecycleOwner, Observer { enabled ->
+            reloadHistoryItem?.isVisible = enabled
+        })
+        historyManager.progress.observe(viewLifecycleOwner, Observer { show ->
+            historyProgressBar.visibility = if (show) VISIBLE else INVISIBLE
+        })
+        historyManager.history.observe(viewLifecycleOwner, Observer { history ->
+            historyEmptyState.visibility = if (history.isEmpty()) VISIBLE else INVISIBLE
+            historyAdapter.update(history)
+        })
+
+        // kicks off initial load, needs to be adapted if showAll state is ever saved
+        if (savedInstanceState == null) historyManager.showAll.value = model.devMode.value
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu, inflater: MenuInflater) {
+        inflater.inflate(R.menu.history, menu)
+        showAllItem = menu.findItem(R.id.show_all_history)
+        showAllItem.isChecked = historyManager.showAll.value == true
+        reloadHistoryItem = menu.findItem(R.id.reload_history).apply {
+            isVisible = model.devMode.value!!
+        }
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem): Boolean {
+        return when (item.itemId) {
+            R.id.show_all_history -> {
+                item.isChecked = !item.isChecked
+                historyManager.showAll.value = item.isChecked
+                true
+            }
+            R.id.reload_history -> {
+                historyManager.showAll.value = showAllItem.isChecked
+                true
+            }
+            else -> super.onOptionsItemSelected(item)
+        }
+    }
+
+    override fun onEventClicked(event: HistoryEvent) {
+        if (model.devMode.value != true) return
+        JsonDialogFragment.new(event.json.toString(4))
+            .show(parentFragmentManager, null)
+    }
+
+}
diff --git a/wallet/src/main/java/net/taler/wallet/payment/AlreadyPaidFragment.kt b/wallet/src/main/java/net/taler/wallet/payment/AlreadyPaidFragment.kt
new file mode 100644
index 0000000..33e3a1d
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/payment/AlreadyPaidFragment.kt
@@ -0,0 +1,47 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+package net.taler.wallet.payment
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.fragment.app.Fragment
+import androidx.navigation.fragment.findNavController
+import kotlinx.android.synthetic.main.fragment_already_paid.*
+import net.taler.wallet.R
+
+/**
+ * Display the message that the user already paid for the order
+ * that the merchant is proposing.
+ */
+class AlreadyPaidFragment : Fragment() {
+
+    override fun onCreateView(
+        inflater: LayoutInflater, container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View? {
+        return inflater.inflate(R.layout.fragment_already_paid, container, false)
+    }
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        backButton.setOnClickListener {
+            findNavController().navigateUp()
+        }
+    }
+
+}
diff --git a/wallet/src/main/java/net/taler/wallet/payment/ContractTerms.kt b/wallet/src/main/java/net/taler/wallet/payment/ContractTerms.kt
new file mode 100644
index 0000000..da91dea
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/payment/ContractTerms.kt
@@ -0,0 +1,56 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+package net.taler.wallet.payment
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties
+import com.fasterxml.jackson.annotation.JsonProperty
+import net.taler.wallet.Amount
+
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+data class ContractTerms(
+    val summary: String,
+    val products: List<ContractProduct>,
+    val amount: Amount
+)
+
+interface Product {
+    val id: String?
+    val description: String
+    val price: Amount
+    val location: String?
+    val image: String?
+}
+
+@JsonIgnoreProperties("totalPrice")
+data class ContractProduct(
+    @JsonProperty("product_id")
+    override val id: String?,
+    override val description: String,
+    override val price: Amount,
+    @JsonProperty("delivery_location")
+    override val location: String?,
+    override val image: String?,
+    val quantity: Int
+) : Product {
+
+    val totalPrice: Amount by lazy {
+        val amount = price.amount.toDouble() * quantity
+        Amount(price.currency, amount.toString())
+    }
+
+}
diff --git a/wallet/src/main/java/net/taler/wallet/payment/PaymentManager.kt b/wallet/src/main/java/net/taler/wallet/payment/PaymentManager.kt
new file mode 100644
index 0000000..ee0edaf
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/payment/PaymentManager.kt
@@ -0,0 +1,160 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+package net.taler.wallet.payment
+
+import android.util.Log
+import androidx.annotation.UiThread
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.MutableLiveData
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.module.kotlin.readValue
+import net.taler.wallet.Amount
+import net.taler.wallet.TAG
+import net.taler.wallet.backend.WalletBackendApi
+import org.json.JSONObject
+import java.net.MalformedURLException
+
+val REGEX_PRODUCT_IMAGE = Regex("^data:image/(jpeg|png);base64,([A-Za-z0-9+/=]+)$")
+
+class PaymentManager(
+    private val walletBackendApi: WalletBackendApi,
+    private val mapper: ObjectMapper
+) {
+
+    private val mPayStatus = MutableLiveData<PayStatus>(PayStatus.None)
+    internal val payStatus: LiveData<PayStatus> = mPayStatus
+
+    private val mDetailsShown = MutableLiveData<Boolean>()
+    internal val detailsShown: LiveData<Boolean> = mDetailsShown
+
+    private var currentPayRequestId = 0
+
+    @UiThread
+    fun preparePay(url: String) {
+        mPayStatus.value = PayStatus.Loading
+        mDetailsShown.value = false
+
+        val args = JSONObject(mapOf("url" to url))
+
+        currentPayRequestId += 1
+        val payRequestId = currentPayRequestId
+
+        walletBackendApi.sendRequest("preparePay", args) { isError, result ->
+            when {
+                isError -> {
+                    Log.v(TAG, "got preparePay error result")
+                    mPayStatus.value = PayStatus.Error(result.toString())
+                }
+                payRequestId != this.currentPayRequestId -> {
+                    Log.v(TAG, "preparePay result was for old request")
+                }
+                else -> {
+                    val status = result.getString("status")
+                    try {
+                        mPayStatus.postValue(getPayStatusUpdate(status, result))
+                    } catch (e: Exception) {
+                        Log.e(TAG, "Error getting PayStatusUpdate", e)
+                        mPayStatus.postValue(PayStatus.Error(e.message ?: "unknown error"))
+                    }
+                }
+            }
+        }
+    }
+
+    private fun getPayStatusUpdate(status: String, json: JSONObject) = when (status) {
+        "payment-possible" -> PayStatus.Prepared(
+            contractTerms = getContractTerms(json),
+            proposalId = json.getString("proposalId"),
+            totalFees = Amount.fromJson(json.getJSONObject("totalFees"))
+        )
+        "paid" -> PayStatus.AlreadyPaid(getContractTerms(json))
+        "insufficient-balance" -> PayStatus.InsufficientBalance(getContractTerms(json))
+        "error" -> PayStatus.Error("got some error")
+        else -> PayStatus.Error("unknown status")
+    }
+
+    private fun getContractTerms(json: JSONObject): ContractTerms {
+        val terms: ContractTerms = mapper.readValue(json.getString("contractTermsRaw"))
+        // validate product images
+        terms.products.forEach { product ->
+            product.image?.let { image ->
+                if (REGEX_PRODUCT_IMAGE.matchEntire(image) == null) {
+                    throw MalformedURLException("Invalid image data URL for ${product.description}")
+                }
+            }
+        }
+        return terms
+    }
+
+    @UiThread
+    fun toggleDetailsShown() {
+        val oldValue = mDetailsShown.value ?: false
+        mDetailsShown.value = !oldValue
+    }
+
+    fun confirmPay(proposalId: String) {
+        val args = JSONObject(mapOf("proposalId" to proposalId))
+
+        walletBackendApi.sendRequest("confirmPay", args) { _, _ ->
+            mPayStatus.postValue(PayStatus.Success)
+        }
+    }
+
+    @UiThread
+    fun abortPay() {
+        val ps = payStatus.value
+        if (ps is PayStatus.Prepared) {
+            abortProposal(ps.proposalId)
+        }
+        resetPayStatus()
+    }
+
+    internal fun abortProposal(proposalId: String) {
+        val args = JSONObject(mapOf("proposalId" to proposalId))
+
+        Log.i(TAG, "aborting proposal")
+
+        walletBackendApi.sendRequest("abortProposal", args) { isError, _ ->
+            if (isError) {
+                Log.e(TAG, "received error response to abortProposal")
+                return@sendRequest
+            }
+            mPayStatus.postValue(PayStatus.None)
+        }
+    }
+
+    @UiThread
+    fun resetPayStatus() {
+        mPayStatus.value = PayStatus.None
+    }
+
+}
+
+sealed class PayStatus {
+    object None : PayStatus()
+    object Loading : PayStatus()
+    data class Prepared(
+        val contractTerms: ContractTerms,
+        val proposalId: String,
+        val totalFees: Amount
+    ) : PayStatus()
+
+    data class InsufficientBalance(val contractTerms: ContractTerms) : PayStatus()
+    data class AlreadyPaid(val contractTerms: ContractTerms) : PayStatus()
+    data class Error(val error: String) : PayStatus()
+    object Success : PayStatus()
+}
diff --git a/wallet/src/main/java/net/taler/wallet/payment/PaymentSuccessfulFragment.kt b/wallet/src/main/java/net/taler/wallet/payment/PaymentSuccessfulFragment.kt
new file mode 100644
index 0000000..2084c45
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/payment/PaymentSuccessfulFragment.kt
@@ -0,0 +1,49 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+package net.taler.wallet.payment
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.fragment.app.Fragment
+import androidx.navigation.fragment.findNavController
+import kotlinx.android.synthetic.main.fragment_payment_successful.*
+import net.taler.wallet.R
+import net.taler.wallet.fadeIn
+
+/**
+ * Fragment that shows the success message for a payment.
+ */
+class PaymentSuccessfulFragment : Fragment() {
+
+    override fun onCreateView(
+        inflater: LayoutInflater, container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View? {
+        return inflater.inflate(R.layout.fragment_payment_successful, container, false)
+    }
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        successImageView.fadeIn()
+        successTextView.fadeIn()
+        backButton.setOnClickListener {
+            findNavController().navigateUp()
+        }
+    }
+
+}
diff --git a/wallet/src/main/java/net/taler/wallet/payment/ProductAdapter.kt b/wallet/src/main/java/net/taler/wallet/payment/ProductAdapter.kt
new file mode 100644
index 0000000..4b1b062
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/payment/ProductAdapter.kt
@@ -0,0 +1,92 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+package net.taler.wallet.payment
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory.decodeByteArray
+import android.util.Base64
+import android.view.LayoutInflater
+import android.view.View
+import android.view.View.GONE
+import android.view.View.VISIBLE
+import android.view.ViewGroup
+import android.widget.ImageView
+import android.widget.TextView
+import androidx.recyclerview.widget.RecyclerView
+import androidx.recyclerview.widget.RecyclerView.ViewHolder
+import net.taler.wallet.R
+import net.taler.wallet.payment.ProductAdapter.ProductViewHolder
+
+internal interface ProductImageClickListener {
+    fun onImageClick(image: Bitmap)
+}
+
+internal class ProductAdapter(private val listener: ProductImageClickListener) :
+    RecyclerView.Adapter<ProductViewHolder>() {
+
+    private val items = ArrayList<ContractProduct>()
+
+    override fun getItemCount() = items.size
+
+    override fun getItemViewType(position: Int): Int {
+        return if (itemCount == 1) 1 else 0
+    }
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ProductViewHolder {
+        val res =
+            if (viewType == 1) R.layout.list_item_product_single else R.layout.list_item_product
+        val view = LayoutInflater.from(parent.context).inflate(res, parent, false)
+        return ProductViewHolder(view)
+    }
+
+    override fun onBindViewHolder(holder: ProductViewHolder, position: Int) {
+        holder.bind(items[position])
+    }
+
+    fun setItems(items: List<ContractProduct>) {
+        this.items.clear()
+        this.items.addAll(items)
+        notifyDataSetChanged()
+    }
+
+    internal inner class ProductViewHolder(v: View) : ViewHolder(v) {
+        private val quantity: TextView = v.findViewById(R.id.quantity)
+        private val image: ImageView = v.findViewById(R.id.image)
+        private val name: TextView = v.findViewById(R.id.name)
+        private val price: TextView = v.findViewById(R.id.price)
+
+        fun bind(product: ContractProduct) {
+            quantity.text = product.quantity.toString()
+            if (product.image == null) {
+                image.visibility = GONE
+            } else {
+                image.visibility = VISIBLE
+                // product.image was validated before, so non-null below
+                val match = REGEX_PRODUCT_IMAGE.matchEntire(product.image)!!
+                val decodedString = Base64.decode(match.groups[2]!!.value, Base64.DEFAULT)
+                val bitmap = decodeByteArray(decodedString, 0, decodedString.size)
+                image.setImageBitmap(bitmap)
+                if (itemCount > 1) image.setOnClickListener {
+                    listener.onImageClick(bitmap)
+                }
+            }
+            name.text = product.description
+            price.text = product.totalPrice.toString()
+        }
+    }
+
+}
diff --git a/wallet/src/main/java/net/taler/wallet/payment/ProductImageFragment.kt b/wallet/src/main/java/net/taler/wallet/payment/ProductImageFragment.kt
new file mode 100644
index 0000000..02414a6
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/payment/ProductImageFragment.kt
@@ -0,0 +1,52 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+package net.taler.wallet.payment
+
+import android.graphics.Bitmap
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.fragment.app.DialogFragment
+import kotlinx.android.synthetic.main.fragment_product_image.*
+import net.taler.wallet.R
+
+class ProductImageFragment private constructor() : DialogFragment() {
+
+    companion object {
+        private const val IMAGE = "image"
+
+        fun new(image: Bitmap) = ProductImageFragment().apply {
+            arguments = Bundle().apply {
+                putParcelable(IMAGE, image)
+            }
+        }
+    }
+
+    override fun onCreateView(
+        inflater: LayoutInflater, container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View? {
+        return inflater.inflate(R.layout.fragment_product_image, container, false)
+    }
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        val bitmap = arguments!!.getParcelable<Bitmap>(IMAGE)
+        productImageView.setImageBitmap(bitmap)
+    }
+
+}
diff --git a/wallet/src/main/java/net/taler/wallet/payment/PromptPaymentFragment.kt b/wallet/src/main/java/net/taler/wallet/payment/PromptPaymentFragment.kt
new file mode 100644
index 0000000..44dcf26
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/payment/PromptPaymentFragment.kt
@@ -0,0 +1,168 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+package net.taler.wallet.payment
+
+import android.annotation.SuppressLint
+import android.graphics.Bitmap
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.View.GONE
+import android.view.View.VISIBLE
+import android.view.ViewGroup
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.activityViewModels
+import androidx.lifecycle.Observer
+import androidx.lifecycle.observe
+import androidx.navigation.fragment.findNavController
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.transition.TransitionManager.beginDelayedTransition
+import kotlinx.android.synthetic.main.payment_bottom_bar.*
+import kotlinx.android.synthetic.main.payment_details.*
+import net.taler.wallet.Amount
+import net.taler.wallet.R
+import net.taler.wallet.WalletViewModel
+import net.taler.wallet.fadeIn
+import net.taler.wallet.fadeOut
+
+/**
+ * Show a payment and ask the user to accept/decline.
+ */
+class PromptPaymentFragment : Fragment(), ProductImageClickListener {
+
+    private val model: WalletViewModel by activityViewModels()
+    private val paymentManager by lazy { model.paymentManager }
+    private val adapter = ProductAdapter(this)
+
+    override fun onCreateView(
+        inflater: LayoutInflater, container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View? {
+        return inflater.inflate(R.layout.fragment_prompt_payment, container, false)
+    }
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        paymentManager.payStatus.observe(viewLifecycleOwner, this::onPaymentStatusChanged)
+        paymentManager.detailsShown.observe(viewLifecycleOwner, Observer { shown ->
+            beginDelayedTransition(view as ViewGroup)
+            val res = if (shown) R.string.payment_hide_details else R.string.payment_show_details
+            detailsButton.setText(res)
+            productsList.visibility = if (shown) VISIBLE else GONE
+        })
+
+        detailsButton.setOnClickListener {
+            paymentManager.toggleDetailsShown()
+        }
+        productsList.apply {
+            adapter = this@PromptPaymentFragment.adapter
+            layoutManager = LinearLayoutManager(requireContext())
+        }
+
+        abortButton.setOnClickListener {
+            paymentManager.abortPay()
+            findNavController().navigateUp()
+        }
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        if (!requireActivity().isChangingConfigurations) {
+            paymentManager.abortPay()
+        }
+    }
+
+    private fun showLoading(show: Boolean) {
+        model.showProgressBar.value = show
+        if (show) {
+            progressBar.fadeIn()
+        } else {
+            progressBar.fadeOut()
+        }
+    }
+
+    private fun onPaymentStatusChanged(payStatus: PayStatus) {
+        when (payStatus) {
+            is PayStatus.Prepared -> {
+                showLoading(false)
+                showOrder(payStatus.contractTerms, payStatus.totalFees)
+                confirmButton.isEnabled = true
+                confirmButton.setOnClickListener {
+                    model.showProgressBar.value = true
+                    paymentManager.confirmPay(payStatus.proposalId)
+                    confirmButton.fadeOut()
+                    confirmProgressBar.fadeIn()
+                }
+            }
+            is PayStatus.InsufficientBalance -> {
+                showLoading(false)
+                showOrder(payStatus.contractTerms, null)
+                errorView.setText(R.string.payment_balance_insufficient)
+                errorView.fadeIn()
+            }
+            is PayStatus.Success -> {
+                showLoading(false)
+                paymentManager.resetPayStatus()
+                findNavController().navigate(R.id.action_promptPayment_to_paymentSuccessful)
+            }
+            is PayStatus.AlreadyPaid -> {
+                showLoading(false)
+                paymentManager.resetPayStatus()
+                findNavController().navigate(R.id.action_promptPayment_to_alreadyPaid)
+            }
+            is PayStatus.Error -> {
+                showLoading(false)
+                errorView.text = getString(R.string.payment_error, payStatus.error)
+                errorView.fadeIn()
+            }
+            is PayStatus.None -> {
+                // No payment active.
+                showLoading(false)
+            }
+            is PayStatus.Loading -> {
+                // Wait until loaded ...
+                showLoading(true)
+            }
+        }
+    }
+
+    private fun showOrder(contractTerms: ContractTerms, totalFees: Amount?) {
+        orderView.text = contractTerms.summary
+        adapter.setItems(contractTerms.products)
+        if (contractTerms.products.size == 1) paymentManager.toggleDetailsShown()
+        val amount = contractTerms.amount
+        @SuppressLint("SetTextI18n")
+        totalView.text = "${amount.amount} ${amount.currency}"
+        if (totalFees != null && !totalFees.isZero()) {
+            val fee = "${totalFees.amount} ${totalFees.currency}"
+            feeView.text = getString(R.string.payment_fee, fee)
+            feeView.fadeIn()
+        } else {
+            feeView.visibility = GONE
+        }
+        orderLabelView.fadeIn()
+        orderView.fadeIn()
+        if (contractTerms.products.size > 1) detailsButton.fadeIn()
+        totalLabelView.fadeIn()
+        totalView.fadeIn()
+    }
+
+    override fun onImageClick(image: Bitmap) {
+        val f = ProductImageFragment.new(image)
+        f.show(parentFragmentManager, "image")
+    }
+
+}
diff --git a/wallet/src/main/java/net/taler/wallet/pending/PendingOperationsFragment.kt b/wallet/src/main/java/net/taler/wallet/pending/PendingOperationsFragment.kt
new file mode 100644
index 0000000..946e5ba
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/pending/PendingOperationsFragment.kt
@@ -0,0 +1,180 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+package net.taler.wallet.pending
+
+import android.os.Bundle
+import android.util.Log
+import android.view.LayoutInflater
+import android.view.Menu
+import android.view.MenuInflater
+import android.view.MenuItem
+import android.view.View
+import android.view.View.GONE
+import android.view.View.VISIBLE
+import android.view.ViewGroup
+import android.widget.LinearLayout
+import android.widget.TextView
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.activityViewModels
+import androidx.lifecycle.Observer
+import androidx.recyclerview.widget.DividerItemDecoration
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import com.google.android.material.snackbar.Snackbar
+import com.google.android.material.snackbar.Snackbar.LENGTH_SHORT
+import kotlinx.android.synthetic.main.fragment_pending_operations.*
+import net.taler.wallet.R
+import net.taler.wallet.TAG
+import net.taler.wallet.WalletViewModel
+import org.json.JSONObject
+
+interface PendingOperationClickListener {
+    fun onPendingOperationClick(type: String, detail: JSONObject)
+    fun onPendingOperationActionClick(type: String, detail: JSONObject)
+}
+
+class PendingOperationsFragment : Fragment(), PendingOperationClickListener {
+
+    private val model: WalletViewModel by activityViewModels()
+    private val pendingOperationsManager by lazy { model.pendingOperationsManager }
+
+    private val pendingAdapter = PendingOperationsAdapter(emptyList(), this)
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setHasOptionsMenu(true)
+    }
+
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View? {
+        return inflater.inflate(R.layout.fragment_pending_operations, container, false)
+    }
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+
+        list_pending.apply {
+            val myLayoutManager = LinearLayoutManager(requireContext())
+            val myItemDecoration =
+                DividerItemDecoration(requireContext(), myLayoutManager.orientation)
+            layoutManager = myLayoutManager
+            adapter = pendingAdapter
+            addItemDecoration(myItemDecoration)
+        }
+
+        pendingOperationsManager.pendingOperations.observe(viewLifecycleOwner, Observer {
+            updatePending(it)
+        })
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem): Boolean {
+        return when (item.itemId) {
+            R.id.retry_pending -> {
+                pendingOperationsManager.retryPendingNow()
+                true
+            }
+            else -> super.onOptionsItemSelected(item)
+        }
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu, inflater: MenuInflater) {
+        inflater.inflate(R.menu.pending_operations, menu)
+        super.onCreateOptionsMenu(menu, inflater)
+    }
+
+    private fun updatePending(pendingOperations: List<PendingOperationInfo>) {
+        pendingAdapter.update(pendingOperations)
+    }
+
+    override fun onPendingOperationClick(type: String, detail: JSONObject) {
+        Snackbar.make(view!!, "No detail view for $type implemented yet.", LENGTH_SHORT).show()
+    }
+
+    override fun onPendingOperationActionClick(type: String, detail: JSONObject) {
+        when (type) {
+            "proposal-choice" -> {
+                Log.v(TAG, "got action click on proposal-choice")
+                val proposalId = detail.optString("proposalId", "")
+                if (proposalId == "") {
+                    return
+                }
+                model.paymentManager.abortProposal(proposalId)
+            }
+        }
+    }
+
+}
+
+class PendingOperationsAdapter(
+    private var items: List<PendingOperationInfo>,
+    private val listener: PendingOperationClickListener
+) :
+    RecyclerView.Adapter<PendingOperationsAdapter.MyViewHolder>() {
+
+    init {
+        setHasStableIds(false)
+    }
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): MyViewHolder {
+        val rowView =
+            LayoutInflater.from(parent.context).inflate(R.layout.pending_row, parent, false)
+        return MyViewHolder(rowView)
+    }
+
+    override fun getItemCount(): Int {
+        return items.size
+    }
+
+    override fun onBindViewHolder(holder: MyViewHolder, position: Int) {
+        val p = items[position]
+        val pendingContainer = holder.rowView.findViewById<LinearLayout>(R.id.pending_container)
+        pendingContainer.setOnClickListener {
+            listener.onPendingOperationClick(p.type, p.detail)
+        }
+        when (p.type) {
+            "proposal-choice" -> {
+                val btn1 = holder.rowView.findViewById<TextView>(R.id.button_pending_action_1)
+                btn1.text = btn1.context.getString(R.string.pending_operations_refuse)
+                btn1.visibility = VISIBLE
+                btn1.setOnClickListener {
+                    listener.onPendingOperationActionClick(p.type, p.detail)
+                }
+            }
+            else -> {
+                val btn1 = holder.rowView.findViewById<TextView>(R.id.button_pending_action_1)
+                btn1.text = btn1.context.getString(R.string.pending_operations_no_action)
+                btn1.visibility = GONE
+                btn1.setOnClickListener {}
+            }
+        }
+        val textView = holder.rowView.findViewById<TextView>(R.id.pending_text)
+        val subTextView = holder.rowView.findViewById<TextView>(R.id.pending_subtext)
+        subTextView.text = p.detail.toString(1)
+        textView.text = p.type
+    }
+
+    fun update(items: List<PendingOperationInfo>) {
+        this.items = items
+        this.notifyDataSetChanged()
+    }
+
+    class MyViewHolder(val rowView: View) : RecyclerView.ViewHolder(rowView)
+
+}
diff --git a/wallet/src/main/java/net/taler/wallet/pending/PendingOperationsManager.kt b/wallet/src/main/java/net/taler/wallet/pending/PendingOperationsManager.kt
new file mode 100644
index 0000000..2125dbc
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/pending/PendingOperationsManager.kt
@@ -0,0 +1,64 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+package net.taler.wallet.pending
+
+import android.util.Log
+import androidx.lifecycle.MutableLiveData
+import net.taler.wallet.TAG
+import net.taler.wallet.backend.WalletBackendApi
+import org.json.JSONObject
+
+open class PendingOperationInfo(
+    val type: String,
+    val detail: JSONObject
+)
+
+class PendingOperationsManager(private val walletBackendApi: WalletBackendApi) {
+
+    private var activeGetPending = 0
+
+    val pendingOperations = MutableLiveData<List<PendingOperationInfo>>()
+
+    internal fun getPending() {
+        if (activeGetPending > 0) {
+            return
+        }
+        activeGetPending++
+        walletBackendApi.sendRequest("getPendingOperations", null) { isError, result ->
+            activeGetPending--
+            if (isError) {
+                Log.i(TAG, "got getPending error result")
+                return@sendRequest
+            }
+            Log.i(TAG, "got getPending result")
+            val pendingList = mutableListOf<PendingOperationInfo>()
+            val pendingJson = result.getJSONArray("pendingOperations")
+            for (i in 0 until pendingJson.length()) {
+                val p = pendingJson.getJSONObject(i)
+                val type = p.getString("type")
+                pendingList.add(PendingOperationInfo(type, p))
+            }
+            Log.i(TAG, "Got ${pendingList.size} pending operations")
+            pendingOperations.postValue((pendingList))
+        }
+    }
+
+    fun retryPendingNow() {
+        walletBackendApi.sendRequest("retryPendingNow", null)
+    }
+
+}
diff --git a/wallet/src/main/java/net/taler/wallet/withdraw/ErrorFragment.kt b/wallet/src/main/java/net/taler/wallet/withdraw/ErrorFragment.kt
new file mode 100644
index 0000000..f0f6610
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/withdraw/ErrorFragment.kt
@@ -0,0 +1,64 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+package net.taler.wallet.withdraw
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.View.GONE
+import android.view.View.VISIBLE
+import android.view.ViewGroup
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.activityViewModels
+import androidx.navigation.fragment.findNavController
+import kotlinx.android.synthetic.main.fragment_error.*
+import net.taler.wallet.R
+import net.taler.wallet.WalletViewModel
+
+class ErrorFragment : Fragment() {
+
+    private val model: WalletViewModel by activityViewModels()
+    private val withdrawManager by lazy { model.withdrawManager }
+
+    override fun onCreateView(
+        inflater: LayoutInflater, container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View? {
+        return inflater.inflate(R.layout.fragment_error, container, false)
+    }
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+
+        errorTitle.setText(R.string.withdraw_error_title)
+        errorMessage.setText(R.string.withdraw_error_message)
+
+        // show dev error message if dev mode is on
+        val status = withdrawManager.withdrawStatus.value
+        if (model.devMode.value == true && status is WithdrawStatus.Error) {
+            errorDevMessage.visibility = VISIBLE
+            errorDevMessage.text = status.message
+        } else {
+            errorDevMessage.visibility = GONE
+        }
+
+        backButton.setOnClickListener {
+            findNavController().navigateUp()
+        }
+    }
+
+}
diff --git a/wallet/src/main/java/net/taler/wallet/withdraw/PromptWithdrawFragment.kt b/wallet/src/main/java/net/taler/wallet/withdraw/PromptWithdrawFragment.kt
new file mode 100644
index 0000000..454816b
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/withdraw/PromptWithdrawFragment.kt
@@ -0,0 +1,109 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+package net.taler.wallet.withdraw
+
+import android.annotation.SuppressLint
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.activityViewModels
+import androidx.lifecycle.Observer
+import androidx.navigation.fragment.findNavController
+import kotlinx.android.synthetic.main.fragment_prompt_withdraw.*
+import net.taler.wallet.R
+import net.taler.wallet.WalletViewModel
+import net.taler.wallet.fadeIn
+import net.taler.wallet.fadeOut
+import net.taler.wallet.withdraw.WithdrawStatus.Loading
+import net.taler.wallet.withdraw.WithdrawStatus.TermsOfServiceReviewRequired
+import net.taler.wallet.withdraw.WithdrawStatus.Withdrawing
+
+class PromptWithdrawFragment : Fragment() {
+
+    private val model: WalletViewModel by activityViewModels()
+    private val withdrawManager by lazy { model.withdrawManager }
+
+    override fun onCreateView(
+        inflater: LayoutInflater, container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View? {
+        return inflater.inflate(R.layout.fragment_prompt_withdraw, container, false)
+    }
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+
+        button_cancel_withdraw.setOnClickListener {
+            withdrawManager.cancelCurrentWithdraw()
+            findNavController().navigateUp()
+        }
+
+        button_confirm_withdraw.setOnClickListener {
+            val status = withdrawManager.withdrawStatus.value
+            if (status !is WithdrawStatus.ReceivedDetails) throw AssertionError()
+            it.fadeOut()
+            confirmProgressBar.fadeIn()
+            withdrawManager.acceptWithdrawal(status.talerWithdrawUri, status.suggestedExchange)
+        }
+
+        withdrawManager.withdrawStatus.observe(viewLifecycleOwner, Observer {
+            showWithdrawStatus(it)
+        })
+    }
+
+    private fun showWithdrawStatus(status: WithdrawStatus?) = when (status) {
+        is WithdrawStatus.ReceivedDetails -> {
+            model.showProgressBar.value = false
+            progressBar.fadeOut()
+
+            introView.fadeIn()
+            @SuppressLint("SetTextI18n")
+            withdrawAmountView.text = "${status.amount.amount} ${status.amount.currency}"
+            withdrawAmountView.fadeIn()
+            feeView.fadeIn()
+
+            exchangeIntroView.fadeIn()
+            withdrawExchangeUrl.text = status.suggestedExchange
+            withdrawExchangeUrl.fadeIn()
+
+            button_confirm_withdraw.isEnabled = true
+        }
+        is WithdrawStatus.Success -> {
+            model.showProgressBar.value = false
+            withdrawManager.withdrawStatus.value = null
+            findNavController().navigate(R.id.action_promptWithdraw_to_withdrawSuccessful)
+        }
+        is Loading -> {
+            model.showProgressBar.value = true
+        }
+        is Withdrawing -> {
+            model.showProgressBar.value = true
+        }
+        is TermsOfServiceReviewRequired -> {
+            model.showProgressBar.value = false
+            findNavController().navigate(R.id.action_promptWithdraw_to_reviewExchangeTOS)
+        }
+        is WithdrawStatus.Error -> {
+            model.showProgressBar.value = false
+            findNavController().navigate(R.id.action_promptWithdraw_to_errorFragment)
+        }
+        null -> model.showProgressBar.value = false
+    }
+
+}
diff --git a/wallet/src/main/java/net/taler/wallet/withdraw/ReviewExchangeTosFragment.kt b/wallet/src/main/java/net/taler/wallet/withdraw/ReviewExchangeTosFragment.kt
new file mode 100644
index 0000000..cd01a33
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/withdraw/ReviewExchangeTosFragment.kt
@@ -0,0 +1,80 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+package net.taler.wallet.withdraw
+
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.activityViewModels
+import androidx.lifecycle.Observer
+import androidx.navigation.fragment.findNavController
+import kotlinx.android.synthetic.main.fragment_review_exchange_tos.*
+import net.taler.wallet.R
+import net.taler.wallet.WalletViewModel
+import net.taler.wallet.fadeIn
+import net.taler.wallet.fadeOut
+
+class ReviewExchangeTosFragment : Fragment() {
+
+    private val model: WalletViewModel by activityViewModels()
+    private val withdrawManager by lazy { model.withdrawManager }
+
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View? {
+        return inflater.inflate(R.layout.fragment_review_exchange_tos, container, false)
+    }
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+        acceptTosCheckBox.isChecked = false
+        acceptTosCheckBox.setOnCheckedChangeListener { _, isChecked ->
+            acceptTosButton.isEnabled = isChecked
+        }
+        abortTosButton.setOnClickListener {
+            withdrawManager.cancelCurrentWithdraw()
+            findNavController().navigateUp()
+        }
+        acceptTosButton.setOnClickListener {
+            withdrawManager.acceptCurrentTermsOfService()
+        }
+        withdrawManager.withdrawStatus.observe(viewLifecycleOwner, Observer {
+            when (it) {
+                is WithdrawStatus.TermsOfServiceReviewRequired -> {
+                    tosTextView.text = it.tosText
+                    tosTextView.fadeIn()
+                    acceptTosCheckBox.fadeIn()
+                    progressBar.fadeOut()
+                }
+                is WithdrawStatus.Loading -> {
+                    findNavController().navigate(R.id.action_reviewExchangeTOS_to_promptWithdraw)
+                }
+                is WithdrawStatus.ReceivedDetails -> {
+                    findNavController().navigate(R.id.action_reviewExchangeTOS_to_promptWithdraw)
+                }
+                else -> {
+                }
+            }
+        })
+    }
+
+}
diff --git a/wallet/src/main/java/net/taler/wallet/withdraw/WithdrawManager.kt b/wallet/src/main/java/net/taler/wallet/withdraw/WithdrawManager.kt
new file mode 100644
index 0000000..e3af757
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/withdraw/WithdrawManager.kt
@@ -0,0 +1,209 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+package net.taler.wallet.withdraw
+
+import android.util.Log
+import androidx.lifecycle.MutableLiveData
+import net.taler.wallet.Amount
+import net.taler.wallet.TAG
+import net.taler.wallet.backend.WalletBackendApi
+import org.json.JSONObject
+
+sealed class WithdrawStatus {
+    data class Loading(val talerWithdrawUri: String) : WithdrawStatus()
+    data class TermsOfServiceReviewRequired(
+        val talerWithdrawUri: String,
+        val exchangeBaseUrl: String,
+        val tosText: String,
+        val tosEtag: String,
+        val amount: Amount,
+        val suggestedExchange: String
+    ) : WithdrawStatus()
+
+    data class ReceivedDetails(
+        val talerWithdrawUri: String,
+        val amount: Amount,
+        val suggestedExchange: String
+    ) : WithdrawStatus()
+
+    data class Withdrawing(val talerWithdrawUri: String) : WithdrawStatus()
+
+    object Success : WithdrawStatus()
+    data class Error(val message: String?) : WithdrawStatus()
+}
+
+class WithdrawManager(private val walletBackendApi: WalletBackendApi) {
+
+    val withdrawStatus = MutableLiveData<WithdrawStatus>()
+    val testWithdrawalInProgress = MutableLiveData(false)
+
+    private var currentWithdrawRequestId = 0
+
+    fun withdrawTestkudos() {
+        testWithdrawalInProgress.value = true
+
+        walletBackendApi.sendRequest("withdrawTestkudos", null) { _, _ ->
+            testWithdrawalInProgress.postValue(false)
+        }
+    }
+
+    fun getWithdrawalInfo(talerWithdrawUri: String) {
+        val args = JSONObject()
+        args.put("talerWithdrawUri", talerWithdrawUri)
+
+        withdrawStatus.value = WithdrawStatus.Loading(talerWithdrawUri)
+
+        this.currentWithdrawRequestId++
+        val myWithdrawRequestId = this.currentWithdrawRequestId
+
+        walletBackendApi.sendRequest("getWithdrawDetailsForUri", args) { isError, result ->
+            if (isError) {
+                Log.e(TAG, "Error getWithdrawDetailsForUri ${result.toString(4)}")
+                val message = if (result.has("message")) result.getString("message") else null
+                withdrawStatus.postValue(WithdrawStatus.Error(message))
+                return@sendRequest
+            }
+            if (myWithdrawRequestId != this.currentWithdrawRequestId) {
+                val mismatch = "$myWithdrawRequestId != ${this.currentWithdrawRequestId}"
+                Log.w(TAG, "Got withdraw result for different request id $mismatch")
+                return@sendRequest
+            }
+            Log.v(TAG, "got getWithdrawDetailsForUri result")
+            val status = withdrawStatus.value
+            if (status !is WithdrawStatus.Loading) {
+                Log.v(TAG, "ignoring withdrawal info result, not loading.")
+                return@sendRequest
+            }
+            val wi = result.getJSONObject("bankWithdrawDetails")
+            val suggestedExchange = wi.getString("suggestedExchange")
+            // We just use the suggested exchange, in the future there will be
+            // a selection dialog.
+            getWithdrawalInfoWithExchange(talerWithdrawUri, suggestedExchange)
+        }
+    }
+
+    private fun getWithdrawalInfoWithExchange(talerWithdrawUri: String, selectedExchange: String) {
+        val args = JSONObject()
+        args.put("talerWithdrawUri", talerWithdrawUri)
+        args.put("selectedExchange", selectedExchange)
+
+        this.currentWithdrawRequestId++
+        val myWithdrawRequestId = this.currentWithdrawRequestId
+
+        walletBackendApi.sendRequest("getWithdrawDetailsForUri", args) { isError, result ->
+            if (isError) {
+                Log.e(TAG, "Error getWithdrawDetailsForUri ${result.toString(4)}")
+                val message = if (result.has("message")) result.getString("message") else null
+                withdrawStatus.postValue(WithdrawStatus.Error(message))
+                return@sendRequest
+            }
+            if (myWithdrawRequestId != this.currentWithdrawRequestId) {
+                val mismatch = "$myWithdrawRequestId != ${this.currentWithdrawRequestId}"
+                Log.w(TAG, "Got withdraw result for different request id $mismatch")
+                return@sendRequest
+            }
+            Log.v(TAG, "got getWithdrawDetailsForUri result (with exchange details)")
+            val status = withdrawStatus.value
+            if (status !is WithdrawStatus.Loading) {
+                Log.v(TAG, "ignoring withdrawal info result, not loading.")
+                return@sendRequest
+            }
+            val wi = result.getJSONObject("bankWithdrawDetails")
+            val suggestedExchange = wi.getString("suggestedExchange")
+            val amount = Amount.fromJson(wi.getJSONObject("amount"))
+
+            val ei = result.getJSONObject("exchangeWithdrawDetails")
+            val termsOfServiceAccepted = ei.getBoolean("termsOfServiceAccepted")
+
+            if (!termsOfServiceAccepted) {
+                val exchange = ei.getJSONObject("exchangeInfo")
+                val tosText = exchange.getString("termsOfServiceText")
+                val tosEtag = exchange.optString("termsOfServiceLastEtag", "undefined")
+                withdrawStatus.postValue(
+                    WithdrawStatus.TermsOfServiceReviewRequired(
+                        status.talerWithdrawUri,
+                        selectedExchange,
+                        tosText,
+                        tosEtag,
+                        amount,
+                        suggestedExchange
+                    )
+                )
+            } else {
+                withdrawStatus.postValue(
+                    WithdrawStatus.ReceivedDetails(
+                        status.talerWithdrawUri,
+                        amount,
+                        suggestedExchange
+                    )
+                )
+            }
+        }
+    }
+
+    fun acceptWithdrawal(talerWithdrawUri: String, selectedExchange: String) {
+        val args = JSONObject()
+        args.put("talerWithdrawUri", talerWithdrawUri)
+        args.put("selectedExchange", selectedExchange)
+
+        withdrawStatus.value = WithdrawStatus.Withdrawing(talerWithdrawUri)
+
+        walletBackendApi.sendRequest("acceptWithdrawal", args) { isError, _ ->
+            if (isError) {
+                Log.v(TAG, "got acceptWithdrawal error result")
+                return@sendRequest
+            }
+            Log.v(TAG, "got acceptWithdrawal result")
+            val status = withdrawStatus.value
+            if (status !is WithdrawStatus.Withdrawing) {
+                Log.v(TAG, "ignoring acceptWithdrawal result, invalid state")
+            }
+            withdrawStatus.postValue(WithdrawStatus.Success)
+        }
+    }
+
+    /**
+     * Accept the currently displayed terms of service.
+     */
+    fun acceptCurrentTermsOfService() {
+        when (val s = withdrawStatus.value) {
+            is WithdrawStatus.TermsOfServiceReviewRequired -> {
+                val args = JSONObject()
+                args.put("exchangeBaseUrl", s.exchangeBaseUrl)
+                args.put("etag", s.tosEtag)
+                walletBackendApi.sendRequest("acceptExchangeTermsOfService", args) { isError, _ ->
+                    if (isError) {
+                        return@sendRequest
+                    }
+                    withdrawStatus.postValue(
+                        WithdrawStatus.ReceivedDetails(
+                            s.talerWithdrawUri,
+                            s.amount,
+                            s.suggestedExchange
+                        )
+                    )
+                }
+            }
+        }
+    }
+
+    fun cancelCurrentWithdraw() {
+        currentWithdrawRequestId++
+        withdrawStatus.value = null
+    }
+
+}
diff --git a/wallet/src/main/java/net/taler/wallet/withdraw/WithdrawSuccessfulFragment.kt b/wallet/src/main/java/net/taler/wallet/withdraw/WithdrawSuccessfulFragment.kt
new file mode 100644
index 0000000..5daeff1
--- /dev/null
+++ b/wallet/src/main/java/net/taler/wallet/withdraw/WithdrawSuccessfulFragment.kt
@@ -0,0 +1,44 @@
+/*
+ * This file is part of GNU Taler
+ * (C) 2020 Taler Systems S.A.
+ *
+ * GNU Taler is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 3, or (at your option) any later version.
+ *
+ * GNU Taler 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+
+package net.taler.wallet.withdraw
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.fragment.app.Fragment
+import androidx.navigation.fragment.findNavController
+import kotlinx.android.synthetic.main.fragment_withdraw_successful.*
+import net.taler.wallet.R
+
+class WithdrawSuccessfulFragment : Fragment() {
+
+    override fun onCreateView(
+        inflater: LayoutInflater, container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View? {
+        return inflater.inflate(R.layout.fragment_withdraw_successful, container, false)
+    }
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+        backButton.setOnClickListener {
+            findNavController().navigateUp()
+        }
+    }
+
+}