Updated on 2026-08-14

app/src/main/java/com/tangem/presentation/activity/PrepareCryptonitOtherAPIWithdrawalActivity.kt

@@ -0,0 +1,238 @@
+package com.tangem.presentation.activity
+
+import android.annotation.SuppressLint
+import android.app.Activity
+import android.content.Intent
+import android.graphics.Color
+import android.nfc.NfcAdapter
+import android.nfc.Tag
+import android.os.Bundle
+import android.support.v7.app.AppCompatActivity
+import android.text.InputFilter
+import android.view.View
+import com.tangem.data.network.Cryptonit_OtherAPI
+import com.tangem.domain.cardReader.NfcManager
+import com.tangem.domain.wallet.Blockchain
+import com.tangem.domain.wallet.CoinEngineFactory
+import com.tangem.domain.wallet.TangemCard
+import com.tangem.util.DecimalDigitsInputFilter
+import com.tangem.wallet.R
+import kotlinx.android.synthetic.main.activity_prepare_cryptonit_other_api_withdrawal.*
+import java.io.IOException
+
+class PrepareCryptonitOtherAPIWithdrawalActivity : AppCompatActivity(), NfcAdapter.ReaderCallback {
+
+    companion object {
+        val TAG: String = PrepareCryptonitOtherAPIWithdrawalActivity::class.java.simpleName
+
+        private const val REQUEST_CODE_SCAN_QR_KEY = 1
+        private const val REQUEST_CODE_SCAN_QR_SECRET = 2
+        private const val REQUEST_CODE_SCAN_QR_USER_ID = 3
+    }
+
+    private var useCurrencyX1000: Boolean = false
+    private var card: TangemCard? = null
+    private var nfcManager: NfcManager? = null
+    private var cryptonit: Cryptonit_OtherAPI? = null
+
+
+    @SuppressLint("SetTextI18n")
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_prepare_cryptonit_other_api_withdrawal)
+
+        MainActivity.commonInit(applicationContext)
+
+        nfcManager = NfcManager(this, this)
+
+        card = TangemCard(intent.getStringExtra("UID"))
+        card!!.loadFromBundle(intent.extras!!.getBundle("Card"))
+
+        cryptonit = Cryptonit_OtherAPI(this)
+
+        tvKey.text = cryptonit!!.key
+        tvUserID.text = cryptonit!!.userId
+        tvSecret.text = cryptonit!!.secretDescription
+
+        tvCardID.text = card!!.cidDescription
+        tvWallet.text = card!!.wallet
+        val engine = CoinEngineFactory.create(card!!.blockchain)
+
+        when (card!!.blockchain) {
+            Blockchain.Ethereum, Blockchain.EthereumTestNet -> {
+                tvCurrency.text = engine.getBalanceCurrency(card)
+                useCurrencyX1000 = false
+
+            }
+            Blockchain.Bitcoin, Blockchain.BitcoinTestNet, Blockchain.BitcoinCash, Blockchain.BitcoinCashTestNet -> {
+                tvCurrency.text = "m" + card!!.blockchain.currency
+                useCurrencyX1000 = true
+            }
+            else -> {
+                tvCurrency.text = engine.getBalanceCurrency(card)
+                useCurrencyX1000 = false
+            }
+        }
+
+        etAmount.setText(engine.convertByteArrayToAmount(card!!, card!!.denomination))
+        when (card!!.blockchain) {
+            Blockchain.Bitcoin ->
+                etAmount.filters = arrayOf<InputFilter>(DecimalDigitsInputFilter(5))
+            Blockchain.BitcoinCash ->
+                etAmount.filters = arrayOf<InputFilter>(DecimalDigitsInputFilter(8))
+            Blockchain.Ethereum ->
+                etAmount.filters = arrayOf<InputFilter>(DecimalDigitsInputFilter(18))
+            else -> {
+            }
+        }
+
+        // set listeners
+        btnLoad.setOnClickListener {
+
+            try {
+                val strAmount: String = etAmount.text.toString().replace(",", ".")
+//                if (!engine.checkAmount(card, strAmount))
+//                    etAmount.error = getString(R.string.unknown_amount_format)
+                var dblAmount: Double = strAmount.toDouble()
+                if (useCurrencyX1000) dblAmount /= 1000.0
+
+                rlProgressBar.visibility = View.VISIBLE
+                tvProgressDescription.text = getString(R.string.cryptonit_request_withdrawal)
+
+                cryptonit!!.requestCryptoWithdrawal(card!!.blockchain.currency, dblAmount.toString(), card!!.wallet)
+            } catch (e: Exception) {
+                etAmount.error = getString(R.string.unknown_amount_format)
+            }
+
+            //Toast.makeText(this, strAmount, Toast.LENGTH_LONG).show()
+//            val balance = engine.getBalanceLong(card)!! / (card!!.blockchain.multiplier / 1000.0)
+//            if (etAmount.text.toString().replace(",", ".").toDouble() > balance) {
+//                etAmount.error = getString(R.string.not_enough_funds_on_your_account)
+//                return@setOnClickListener
+//            }
+
+        }
+        ivCameraKey.setOnClickListener {
+            val intent = Intent(baseContext, QrScanActivity::class.java)
+            startActivityForResult(intent, REQUEST_CODE_SCAN_QR_KEY)
+        }
+        ivCameraSecret.setOnClickListener {
+            val intent = Intent(baseContext, QrScanActivity::class.java)
+            startActivityForResult(intent, REQUEST_CODE_SCAN_QR_SECRET)
+        }
+        ivCameraUserId.setOnClickListener {
+            val intent = Intent(baseContext, QrScanActivity::class.java)
+            startActivityForResult(intent, REQUEST_CODE_SCAN_QR_USER_ID)
+        }
+
+        ivRefreshBalance.setOnClickListener { doRequestBalance() }
+
+        cryptonit!!.setBalanceListener { response ->
+            when (card!!.blockchain) {
+                Blockchain.Ethereum, Blockchain.EthereumTestNet -> {
+                    tvBalance.text = response.eth_available
+                }
+                Blockchain.Bitcoin, Blockchain.BitcoinTestNet, Blockchain.BitcoinCash, Blockchain.BitcoinCashTestNet -> {
+                    tvBalance.text = response.btc_available
+                }
+                else -> {
+                }
+            }
+
+            tvBalanceCurrency.text = card!!.blockchain.currency
+            tvBalance.setTextColor(Color.BLACK)
+            rlProgressBar.visibility = View.INVISIBLE
+            btnLoad.isActivated = true
+        }
+        cryptonit!!.setErrorListener { throwable ->
+            throwable.printStackTrace()
+            rlProgressBar.visibility = View.INVISIBLE
+            tvError.visibility = View.VISIBLE
+            tvError.text = throwable.message
+        }
+        cryptonit!!.setWithdrawalListener { response ->
+            rlProgressBar.visibility = View.INVISIBLE
+            if (response.success != null && response.success!!) finish()
+            else {
+                tvError.visibility = View.VISIBLE
+                tvError.text = response.reason!!.toString()
+            }
+        }
+        btnLoad.isActivated = false
+        doRequestBalance()
+    }
+
+    private fun doRequestBalance() {
+        if (cryptonit!!.havaAccountInfo()) {
+            rlProgressBar.visibility = View.VISIBLE
+            tvProgressDescription.text = getString(R.string.cryptonit_request_balance)
+            tvError.visibility = View.INVISIBLE
+            cryptonit!!.requestBalance(card!!.blockchain.currency, "USD")
+        } else {
+            tvError.visibility = View.VISIBLE
+            tvError.text = getString(R.string.cryptonit_not_enough_account_data)
+        }
+    }
+
+//    private fun EditText.afterTextChanged(afterTextChanged: (String) -> Unit) {
+//        this.addTextChangedListener(object : TextWatcher {
+//            override fun beforeTextChanged(p0: CharSequence?, p1: Int, p2: Int, p3: Int) {
+//            }
+//
+//            override fun onTextChanged(p0: CharSequence?, p1: Int, p2: Int, p3: Int) {
+//            }
+//
+//            override fun afterTextChanged(editable: Editable?) {
+//                afterTextChanged.invoke(editable.toString())
+//            }
+//        })
+//    }
+
+    public override fun onResume() {
+        super.onResume()
+        nfcManager!!.onResume()
+    }
+
+    public override fun onPause() {
+        super.onPause()
+        nfcManager!!.onPause()
+    }
+
+    public override fun onStop() {
+        super.onStop()
+        nfcManager!!.onStop()
+    }
+
+    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
+        super.onActivityResult(requestCode, resultCode, data)
+        if( resultCode == Activity.RESULT_OK && data != null && data.extras!!.containsKey("QRCode") ) {
+            when(requestCode) {
+                REQUEST_CODE_SCAN_QR_KEY -> {
+                    cryptonit!!.key = data.getStringExtra("QRCode")
+                    tvKey!!.text = cryptonit!!.key
+                }
+                REQUEST_CODE_SCAN_QR_SECRET -> {
+                    cryptonit!!.secret = data.getStringExtra("QRCode")
+                    tvSecret!!.text = cryptonit!!.secretDescription
+                }
+                REQUEST_CODE_SCAN_QR_USER_ID -> {
+                    cryptonit!!.userId = data.getStringExtra("QRCode")
+                    tvUserID!!.text = cryptonit!!.userId
+                }
+            }
+            cryptonit!!.saveAccountInfo()
+            doRequestBalance()
+        }
+    }
+
+    override fun onTagDiscovered(tag: Tag) {
+        try {
+//            Log.w(javaClass.name, "Ignore discovered tag!")
+            nfcManager!!.ignoreTag(tag)
+        } catch (e: IOException) {
+            e.printStackTrace()
+        }
+
+    }
+
+}

app/src/main/java/com/tangem/presentation/activity/PrepareCryptonitWithdrawalActivity.kt

@@ -0,0 +1,185 @@
+package com.tangem.presentation.activity
+
+import android.annotation.SuppressLint
+import android.graphics.Color
+import android.nfc.NfcAdapter
+import android.nfc.Tag
+import android.os.Bundle
+import android.support.v7.app.AppCompatActivity
+import android.text.InputFilter
+import android.view.View
+import android.widget.Toast
+import com.tangem.data.network.Cryptonit
+import com.tangem.domain.cardReader.NfcManager
+import com.tangem.domain.wallet.Blockchain
+import com.tangem.domain.wallet.CoinEngineFactory
+import com.tangem.domain.wallet.TangemCard
+import com.tangem.util.DecimalDigitsInputFilter
+import com.tangem.wallet.R
+import kotlinx.android.synthetic.main.activity_prepare_cryptonit_withdrawal.*
+import java.io.IOException
+
+class PrepareCryptonitWithdrawalActivity : AppCompatActivity(), NfcAdapter.ReaderCallback {
+
+    companion object {
+        val TAG: String = PrepareCryptonitWithdrawalActivity::class.java.simpleName
+    }
+
+    private var useCurrencyX1000: Boolean = false
+    private var card: TangemCard? = null
+    private var nfcManager: NfcManager? = null
+    private var cryptonit: Cryptonit? = null
+
+
+    @SuppressLint("SetTextI18n")
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_prepare_cryptonit_withdrawal)
+
+        MainActivity.commonInit(applicationContext)
+
+        nfcManager = NfcManager(this, this)
+
+        card = TangemCard(intent.getStringExtra("UID"))
+        card!!.loadFromBundle(intent.extras!!.getBundle("Card"))
+
+        cryptonit = Cryptonit(this)
+
+        etUsername.setText(cryptonit!!.username)
+        etPassword.setText(cryptonit!!.password)
+        etFee.setText(cryptonit!!.fee)
+
+        tvCardID.text = card!!.cidDescription
+        tvWallet.text = card!!.wallet
+        val engine = CoinEngineFactory.create(card!!.blockchain)
+
+        when (card!!.blockchain) {
+            Blockchain.Ethereum -> {
+                tvCurrency.text = engine.getBalanceCurrency(card)
+                useCurrencyX1000 = false
+
+            }
+            Blockchain.Bitcoin, Blockchain.BitcoinCash -> {
+                tvCurrency.text = "m" + card!!.blockchain.currency
+                useCurrencyX1000 = true
+            }
+            else -> {
+                tvCurrency.text = engine.getBalanceCurrency(card)
+                useCurrencyX1000 = false
+            }
+        }
+        tvFeeCurrency.text = tvCurrency.text
+
+        etAmount.setText(engine.convertByteArrayToAmount(card!!, card!!.denomination))
+        when (card!!.blockchain) {
+            Blockchain.Bitcoin -> {
+                etAmount.filters = arrayOf<InputFilter>(DecimalDigitsInputFilter(5))
+                etFee.filters = arrayOf<InputFilter>(DecimalDigitsInputFilter(5))
+            }
+            Blockchain.BitcoinCash -> {
+                etAmount.filters = arrayOf<InputFilter>(DecimalDigitsInputFilter(8))
+                etFee.filters = arrayOf<InputFilter>(DecimalDigitsInputFilter(8))
+            }
+            Blockchain.Ethereum -> {
+                etAmount.filters = arrayOf<InputFilter>(DecimalDigitsInputFilter(18))
+                etFee.filters = arrayOf<InputFilter>(DecimalDigitsInputFilter(18))
+            }
+            else -> {
+            }
+        }
+
+        // set listeners
+        btnLoad.setOnClickListener {
+
+            try {
+                val strAmount: String = etAmount.text.toString().replace(",", ".")
+                val strFee: String = etFee.text.toString().replace(",", ".")
+                var dblAmount: Double = strAmount.toDouble()
+                var dblFee: Double = strFee.toDouble()
+                if (useCurrencyX1000){
+                    dblAmount /= 1000.0
+                    dblFee /= 1000.0
+                }
+                cryptonit!!.fee=strFee
+
+                rlProgressBar.visibility = View.VISIBLE
+                tvProgressDescription.text = getString(R.string.cryptonit_request_withdrawal)
+
+                cryptonit!!.requestWithdrawCoins(card!!.blockchain.currency, dblAmount, card!!.wallet)
+            } catch (e: Exception) {
+                etAmount.error = getString(R.string.unknown_amount_format)
+            }
+        }
+
+        ivRefreshBalance.setOnClickListener {
+            cryptonit!!.username=etUsername.text.toString()
+            cryptonit!!.password=etPassword.text.toString()
+            cryptonit!!.saveAccountInfo()
+            doRequestBalance()
+        }
+
+        cryptonit!!.setBalanceListener { response ->
+            tvBalance.text = response.results[0].balance.toString()
+            tvBalanceCurrency.text = response.results[0].currency // card!!.blockchain.currency
+            tvBalance.setTextColor(Color.BLACK)
+            rlProgressBar.visibility = View.INVISIBLE
+            btnLoad.visibility = View.VISIBLE
+        }
+        cryptonit!!.setErrorListener { throwable ->
+            throwable.printStackTrace()
+            rlProgressBar.visibility = View.INVISIBLE
+            tvError.visibility = View.VISIBLE
+            tvError.text = throwable.message
+        }
+        cryptonit!!.setWithdrawalListener { response ->
+            rlProgressBar.visibility = View.INVISIBLE
+            if (response.success != null && response.success!!){
+                Toast.makeText(this,"Withdrawal successful!", Toast.LENGTH_LONG).show();
+                finish()
+            }
+            else {
+                tvError.visibility = View.VISIBLE
+                tvError.text = response.errors.toString()
+            }
+        }
+        btnLoad.visibility = View.INVISIBLE
+        doRequestBalance()
+    }
+
+    private fun doRequestBalance() {
+        if (cryptonit!!.haveAccountInfo()) {
+            rlProgressBar.visibility = View.VISIBLE
+            tvProgressDescription.text = getString(R.string.cryptonit_request_balance)
+            tvError.visibility = View.INVISIBLE
+            cryptonit!!.requestBalance(card!!.blockchain.currency)
+        } else {
+            tvError.visibility = View.VISIBLE
+            tvError.text = getString(R.string.cryptonit_not_enough_account_data)
+        }
+    }
+
+    public override fun onResume() {
+        super.onResume()
+        nfcManager!!.onResume()
+    }
+
+    public override fun onPause() {
+        super.onPause()
+        nfcManager!!.onPause()
+    }
+
+    public override fun onStop() {
+        super.onStop()
+        nfcManager!!.onStop()
+    }
+
+    override fun onTagDiscovered(tag: Tag) {
+        try {
+            nfcManager!!.ignoreTag(tag)
+        } catch (e: IOException) {
+            e.printStackTrace()
+        }
+
+    }
+
+}

app/src/main/java/com/tangem/presentation/activity/PrepareKrakenWithdrawalActivity.kt

@@ -0,0 +1,286 @@
+package com.tangem.presentation.activity
+
+import android.annotation.SuppressLint
+import android.app.Activity
+import android.app.AlertDialog
+import android.content.DialogInterface
+import android.content.Intent
+import android.graphics.Color
+import android.nfc.NfcAdapter
+import android.nfc.Tag
+import android.os.Bundle
+import android.support.v7.app.AppCompatActivity
+import android.text.InputFilter
+import android.view.View
+import android.widget.Toast
+import com.tangem.data.network.Kraken
+import com.tangem.domain.cardReader.NfcManager
+import com.tangem.domain.wallet.Blockchain
+import com.tangem.domain.wallet.CoinEngineFactory
+import com.tangem.domain.wallet.TangemCard
+import com.tangem.util.DecimalDigitsInputFilter
+import com.tangem.wallet.R
+import kotlinx.android.synthetic.main.activity_prepare_kraken_withdrawal.*
+import java.io.IOException
+import java.math.BigDecimal
+import java.net.URI
+import java.util.*
+
+class PrepareKrakenWithdrawalActivity : AppCompatActivity(), NfcAdapter.ReaderCallback {
+
+    companion object {
+        val TAG: String = PrepareKrakenWithdrawalActivity::class.java.simpleName
+
+        private const val REQUEST_CODE_SCAN_QR = 1
+    }
+
+    private var useCurrencyX1000: Boolean = false
+    private var card: TangemCard? = null
+    private var nfcManager: NfcManager? = null
+    private var kraken: Kraken? = null
+    private var fee: BigDecimal? = null
+
+    @SuppressLint("SetTextI18n")
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_prepare_kraken_withdrawal)
+
+        MainActivity.commonInit(applicationContext)
+
+        nfcManager = NfcManager(this, this)
+
+        card = TangemCard(intent.getStringExtra("UID"))
+        card!!.loadFromBundle(intent.extras!!.getBundle("Card"))
+
+        kraken = Kraken(this)
+
+        tvKey.text = kraken!!.key
+        tvSecret.text = kraken!!.secretDescription
+
+        tvCardID.text = card!!.cidDescription
+        tvWallet.text = card!!.wallet
+        val engine = CoinEngineFactory.create(card!!.blockchain)
+
+        when (card!!.blockchain) {
+            Blockchain.Ethereum, Blockchain.EthereumTestNet -> {
+                tvCurrency.text = engine.getBalanceCurrency(card)
+                useCurrencyX1000 = false
+
+            }
+            Blockchain.Bitcoin, Blockchain.BitcoinTestNet, Blockchain.BitcoinCash, Blockchain.BitcoinCashTestNet -> {
+                tvCurrency.text = "m" + card!!.blockchain.currency
+                useCurrencyX1000 = true
+            }
+            else -> {
+                tvCurrency.text = engine.getBalanceCurrency(card)
+                useCurrencyX1000 = false
+            }
+        }
+
+        etAmount.setText(engine.convertByteArrayToAmount(card!!, card!!.denomination))
+        when (card!!.blockchain) {
+            Blockchain.Bitcoin ->
+                etAmount.filters = arrayOf<InputFilter>(DecimalDigitsInputFilter(5))
+            Blockchain.BitcoinCash ->
+                etAmount.filters = arrayOf<InputFilter>(DecimalDigitsInputFilter(8))
+            Blockchain.Ethereum ->
+                etAmount.filters = arrayOf<InputFilter>(DecimalDigitsInputFilter(18))
+            else -> {
+            }
+        }
+
+        // set listeners
+        btnLoad.setOnClickListener {
+
+            try {
+                val strAmount: String = etAmount.text.toString().replace(",", ".")
+
+                var dblAmount: Double = strAmount.toDouble()
+                if (useCurrencyX1000) dblAmount /= 1000.0
+
+                rlProgressBar.visibility = View.VISIBLE
+                tvProgressDescription.text = getString(R.string.kraken_request_withdrawal)
+
+                kraken!!.requestWithdrawInfo(card!!.blockchain.currency, dblAmount.toString(), card!!.wallet)
+            } catch (e: Exception) {
+                etAmount.error = getString(R.string.unknown_amount_format)
+            }
+
+        }
+        ivCamera.setOnClickListener {
+            val intent = Intent(baseContext, QrScanActivity::class.java)
+            startActivityForResult(intent, REQUEST_CODE_SCAN_QR)
+        }
+
+        ivRefreshBalance.setOnClickListener { doRequestBalance() }
+
+        kraken!!.setBalanceListener { response ->
+            if (response.error != null && response.error.isNotEmpty()) {
+                tvError.visibility = View.VISIBLE
+                tvError.text = Arrays.toString(response.error)
+            } else {
+                when (card!!.blockchain) {
+                    Blockchain.Ethereum -> {
+                        tvBalance.text = response.result.XETH.trimEnd('0')
+                    }
+                    Blockchain.Bitcoin -> {
+                        tvBalance.text = response.result.XXBT.trimEnd('0')
+                    }
+                    Blockchain.BitcoinCash -> {
+                        tvBalance.text = response.result.BCH.trimEnd('0')
+                    }
+                    else -> {
+                        tvBalance.text = "???"
+                    }
+                }
+                tvBalanceCurrency.text = card!!.blockchain.currency
+                tvBalance.setTextColor(Color.BLACK)
+                btnLoad.visibility = View.VISIBLE
+            }
+            rlProgressBar.visibility = View.INVISIBLE
+        }
+        kraken!!.setErrorListener { throwable ->
+            throwable.printStackTrace()
+            rlProgressBar.visibility = View.INVISIBLE
+            tvError.visibility = View.VISIBLE
+            tvError.text = throwable.message
+        }
+        kraken!!.setWithdrawalListener { response ->
+            rlProgressBar.visibility = View.INVISIBLE
+            if (response.error != null && response.error.isNotEmpty()) {
+                tvError.visibility = View.VISIBLE
+                tvError.text = Arrays.toString(response.error)
+            } else {
+                Toast.makeText(this,"Withdrawal successful!", Toast.LENGTH_LONG).show()
+                finish()
+            }
+        }
+        kraken!!.setWithdrawalInfoListener { response ->
+            rlProgressBar.visibility = View.INVISIBLE
+            if (response.error != null && response.error.isNotEmpty()) {
+                tvError.visibility = View.VISIBLE
+                tvError.text = Arrays.toString(response.error)
+            } else {
+                fee = BigDecimal(response.result.fee)
+                showConfirmDialog()
+            }
+        }
+        btnLoad.visibility = View.INVISIBLE
+        doRequestBalance()
+    }
+
+    // Method to show an alert dialog with yes, no and cancel button
+    private fun showConfirmDialog() {
+        // Late initialize an alert dialog object
+        lateinit var dialog: AlertDialog
+
+
+        // Initialize a new instance of alert dialog builder object
+        val builder = AlertDialog.Builder(this)
+
+        // Set a title for alert dialog
+        builder.setTitle("Please confirm withdraw")
+
+        // Set a message for alert dialog
+        builder.setMessage(String.format("Continue with fee %s %s?", fee!!.toString().trimEnd('0'),card!!.blockchain.currency))
+
+        // On click listener for dialog buttons
+        val dialogClickListener = DialogInterface.OnClickListener { _, which ->
+            when (which) {
+                DialogInterface.BUTTON_POSITIVE -> {
+                    try {
+                        val strAmount: String = etAmount.text.toString().replace(",", ".")
+
+                        var dblAmount: Double = strAmount.toDouble()
+                        if (useCurrencyX1000) dblAmount /= 1000.0
+
+                        dblAmount+=fee!!.toDouble()
+
+                        rlProgressBar.visibility = View.VISIBLE
+                        tvProgressDescription.text = getString(R.string.kraken_request_withdrawal)
+
+                        //Toast.makeText(this, String.format("Withdraw %s!",dblAmount.toString()), Toast.LENGTH_LONG).show()
+                        kraken!!.requestWithdraw(card!!.blockchain.currency, dblAmount.toString(), card!!.wallet)
+                    } catch (e: Exception) {
+                        etAmount.error = getString(R.string.unknown_amount_format)
+                    }
+                }
+                DialogInterface.BUTTON_NEGATIVE -> {
+                    Toast.makeText(this, "Operation canceled!", Toast.LENGTH_LONG).show()
+                }
+            }
+        }
+
+        // Set the alert dialog positive/yes button
+        builder.setPositiveButton("YES", dialogClickListener)
+
+        // Set the alert dialog negative/no button
+        builder.setNegativeButton("NO", dialogClickListener)
+
+
+        // Initialize the AlertDialog using builder object
+        dialog = builder.create()
+
+        // Finally, display the alert dialog
+        dialog.show()
+    }
+
+    private fun doRequestBalance() {
+        if (kraken!!.haveAccountInfo()) {
+            rlProgressBar.visibility = View.VISIBLE
+            tvProgressDescription.text = getString(R.string.kraken_request_balance)
+            tvError.visibility = View.INVISIBLE
+            kraken!!.requestBalance()
+        } else {
+            tvError.visibility = View.VISIBLE
+            tvError.text = getString(R.string.kraken_not_enough_account_data)
+        }
+    }
+
+    public override fun onResume() {
+        super.onResume()
+        nfcManager!!.onResume()
+    }
+
+    public override fun onPause() {
+        super.onPause()
+        nfcManager!!.onPause()
+    }
+
+    public override fun onStop() {
+        super.onStop()
+        nfcManager!!.onStop()
+    }
+
+    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
+        super.onActivityResult(requestCode, resultCode, data)
+        if (resultCode == Activity.RESULT_OK && data != null && data.extras!!.containsKey("QRCode")) {
+            when (requestCode) {
+                REQUEST_CODE_SCAN_QR -> {
+                    val uri = URI(data.getStringExtra("QRCode"))
+                    var query = uri.query
+                    var params = query.split("&")
+                    for (param in params) {
+                        if (param.startsWith("key=")) kraken!!.key = param.substring(4)
+                        else if (param.startsWith("secret=")) kraken!!.secret = param.substring(7)
+                    }
+                    tvKey!!.text = kraken!!.key
+                    tvSecret!!.text = kraken!!.secretDescription
+                }
+            }
+            kraken!!.saveAccountInfo()
+            doRequestBalance()
+        }
+    }
+
+    override fun onTagDiscovered(tag: Tag) {
+        try {
+//            Log.w(javaClass.name, "Ignore discovered tag!")
+            nfcManager!!.ignoreTag(tag)
+        } catch (e: IOException) {
+            e.printStackTrace()
+        }
+
+    }
+
+}

app/src/main/java/com/tangem/presentation/fragment/LoadedWallet.kt

@@ -1,6 +1,7 @@
 package com.tangem.presentation.fragment
 
 import android.app.Activity
+import android.app.AlertDialog
 import android.content.*
 import android.content.Context.CLIPBOARD_SERVICE
 import android.content.pm.PackageManager
@@ -36,6 +37,7 @@ import com.tangem.presentation.dialog.PINSwapWarningDialog
 import com.tangem.presentation.dialog.WaitSecurityDelayDialog
 import com.tangem.util.Util
 import com.tangem.util.UtilHelper
+import com.tangem.wallet.BuildConfig
 import com.tangem.wallet.R
 import kotlinx.android.synthetic.main.fr_loaded_wallet.*
 import java.util.*
@@ -51,6 +53,7 @@ class LoadedWallet : Fragment(), NfcAdapter.ReaderCallback, CardProtocol.Notific
         private const val REQUEST_CODE_ENTER_NEW_PIN2 = 6
         private const val REQUEST_CODE_REQUEST_PIN2_FOR_SWAP_PIN = 7
         private const val REQUEST_CODE_SWAP_PIN = 8
+        private const val REQUEST_CODE_RECEIVE_PAYMENT = 9
     }
 
     private var singleToast: Toast? = null
@@ -133,12 +136,53 @@ class LoadedWallet : Fragment(), NfcAdapter.ReaderCallback, CardProtocol.Notific
         tvWallet.setOnClickListener { doShareWallet(false) }
         ivQR.setOnClickListener { doShareWallet(true) }
         btnLoad.setOnClickListener {
-            try {
-                val intent = Intent(Intent.ACTION_VIEW, CoinEngineFactory.create(card!!.blockchain)!!.getShareWalletUri(card))
-                intent.addCategory(Intent.CATEGORY_DEFAULT)
-                startActivity(intent)
-            } catch (e: ActivityNotFoundException) {
-                showSingleToast(R.string.no_compatible_wallet)
+            if (BuildConfig.DEBUG) {
+                val items = arrayOf<CharSequence>(getString(R.string.in_app), getString(R.string.via_cryptonit), getString(R.string.via_kraken))
+                val dialog = AlertDialog.Builder(activity).setTitle(getString(R.string.select_loading_method)).setItems(items
+                ) { _, which ->
+                    when (items[which]) {
+                        getString(R.string.in_app) -> {
+                            try {
+                                val intent = Intent(Intent.ACTION_VIEW, CoinEngineFactory.create(card!!.blockchain)!!.getShareWalletUri(card))
+                                intent.addCategory(Intent.CATEGORY_DEFAULT)
+                                startActivity(intent)
+                            } catch (e: ActivityNotFoundException) {
+                                showSingleToast(R.string.no_compatible_wallet)
+                            }
+
+                        }
+//                        getString(R.string.via_cryptonit2) -> {
+//                            val intent = Intent(context, PrepareCryptonitOtherAPIWithdrawalActivity::class.java)
+//                            intent.putExtra("UID", card!!.uid)
+//                            intent.putExtra("Card", card!!.asBundle)
+//                            startActivityForResult(intent, REQUEST_CODE_RECEIVE_PAYMENT)
+//                        }
+                        getString(R.string.via_cryptonit) -> {
+                            val intent = Intent(context, PrepareCryptonitWithdrawalActivity::class.java)
+                            intent.putExtra("UID", card!!.uid)
+                            intent.putExtra("Card", card!!.asBundle)
+                            startActivityForResult(intent, REQUEST_CODE_RECEIVE_PAYMENT)
+                        }
+                        getString(R.string.via_kraken) -> {
+                            val intent = Intent(context, PrepareKrakenWithdrawalActivity::class.java)
+                            intent.putExtra("UID", card!!.uid)
+                            intent.putExtra("Card", card!!.asBundle)
+                            startActivityForResult(intent, REQUEST_CODE_RECEIVE_PAYMENT)
+                        }
+                        else -> {
+                        }
+                    }
+
+                }
+                dialog.show()
+            } else {
+                try {
+                    val intent = Intent(Intent.ACTION_VIEW, CoinEngineFactory.create(card!!.blockchain)!!.getShareWalletUri(card))
+                    intent.addCategory(Intent.CATEGORY_DEFAULT)
+                    startActivity(intent)
+                } catch (e: ActivityNotFoundException) {
+                    showSingleToast(R.string.no_compatible_wallet)
+                }
             }
         }
         btnDetails.setOnClickListener {
@@ -351,7 +395,7 @@ class LoadedWallet : Fragment(), NfcAdapter.ReaderCallback, CardProtocol.Notific
                 }
                 updateViews()
             }
-            REQUEST_CODE_SEND_PAYMENT -> {
+            REQUEST_CODE_SEND_PAYMENT, REQUEST_CODE_RECEIVE_PAYMENT -> {
                 if (resultCode == Activity.RESULT_OK) {
                     srlLoadedWallet!!.postDelayed({ this.refresh() }, 10000)
                     srlLoadedWallet!!.isRefreshing = true