Updated on 2026-08-14

app/src/main/java/com/tangem/data/Blockchain.java

@@ -12,7 +12,8 @@ public enum Blockchain {
     Ethereum("ETH", "ETH", 1.0, R.drawable.ic_logo_ethereum, "Ethereum"),
     EthereumTestNet("ETH/test", "ETH", 1.0, R.drawable.ic_logo_ethereum_testnet, "Ethereum Testnet"),
     Token("Token", "ERC20", 1.0, R.drawable.ic_logo_bat_token, "Ethereum"),
-    BitcoinCash("BCH", "BCH", 100000000.0, R.drawable.ic_logo_bitcoin_cash, "Bitcoin Cash");
+    BitcoinCash("BCH", "BCH", 100000000.0, R.drawable.ic_logo_bitcoin_cash, "Bitcoin Cash"),
+    Litecoin("LTC", "LTC", 100000000.0, R.drawable.ic_logo_bitcoin, "Litecoin");
 
     Blockchain(String ID, String currency, double multiplier, int imageResource, String officialName) {
         mID = ID;

app/src/main/java/com/tangem/data/network/ServerApiElectrum.java

@@ -8,6 +8,7 @@ import com.tangem.data.Blockchain;
 import com.tangem.domain.wallet.bch.BitcoinCashNode;
 import com.tangem.domain.wallet.btc.BitcoinNode;
 import com.tangem.domain.wallet.btc.BitcoinNodeTestNet;
+import com.tangem.domain.wallet.ltc.LitecoinNode;
 
 import java.io.BufferedReader;
 import java.io.IOException;
@@ -144,6 +145,20 @@ public class ServerApiElectrum {
             this.host = host;
             this.port = port;
 
+            if (proto.equals("tcp")) {
+                return doElectrumRequestTcp(electrumRequest, host, port);
+            } else {
+                return doElectrumRequestSsl(electrumRequest, host, port);
+            }
+        } else if (ctx.getBlockchain() == Blockchain.Litecoin) {
+            LitecoinNode litecoinNode = LitecoinNode.values()[new Random().nextInt(LitecoinNode.values().length)];
+            host = litecoinNode.getHost();
+            port = litecoinNode.getPort();
+            proto = litecoinNode.getProto();
+
+            this.host = host;
+            this.port = port;
+
             if (proto.equals("tcp")) {
                 return doElectrumRequestTcp(electrumRequest, host, port);
             } else {

app/src/main/java/com/tangem/domain/wallet/CoinEngineFactory.kt

@@ -7,6 +7,7 @@ import com.tangem.domain.wallet.eth.EthEngine
 import com.tangem.domain.wallet.token.TokenEngine
 import com.tangem.domain.wallet.bch.BtcCashEngine
 import com.tangem.data.Blockchain
+import com.tangem.domain.wallet.ltc.LtcEngine
 
 /**
  * Factory for create specific engine
@@ -25,6 +26,7 @@ object CoinEngineFactory {
             Blockchain.BitcoinCash -> BtcCashEngine()
             Blockchain.Ethereum, Blockchain.EthereumTestNet -> EthEngine()
             Blockchain.Token -> TokenEngine()
+            Blockchain.Litecoin -> LtcEngine()
             else -> null
         }
     }
@@ -40,6 +42,8 @@ object CoinEngineFactory {
                 EthEngine(context)
             else if (Blockchain.Token == context.blockchain)
                 TokenEngine(context)
+            else if (Blockchain.Litecoin == context.blockchain)
+                LtcEngine(context)
             else
                 return null
         } catch (e: Exception) {

app/src/main/java/com/tangem/domain/wallet/ltc/LtcEngine.java

@@ -0,0 +1,570 @@
+package com.tangem.domain.wallet.ltc;
+
+import android.net.Uri;
+import android.text.InputFilter;
+
+import com.tangem.data.Blockchain;
+import com.tangem.domain.wallet.BTCUtils;
+import com.tangem.domain.wallet.BalanceValidator;
+import com.tangem.domain.wallet.Base58;
+import com.tangem.domain.wallet.CoinData;
+import com.tangem.domain.wallet.CoinEngine;
+import com.tangem.domain.wallet.TangemContext;
+import com.tangem.domain.wallet.Transaction;
+import com.tangem.domain.wallet.UnspentOutputInfo;
+import com.tangem.domain.wallet.btc.BtcData;
+import com.tangem.tangemcard.data.TangemCard;
+import com.tangem.tangemcard.reader.CardProtocol;
+import com.tangem.tangemcard.tasks.SignTask;
+import com.tangem.tangemcard.util.Util;
+import com.tangem.util.CryptoUtil;
+import com.tangem.util.DecimalDigitsInputFilter;
+import com.tangem.util.DerEncodingUtil;
+import com.tangem.wallet.R;
+
+import java.io.ByteArrayOutputStream;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.nio.ByteBuffer;
+import java.security.NoSuchAlgorithmException;
+import java.security.NoSuchProviderException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class LtcEngine extends CoinEngine {
+
+    public BtcData coinData = null;
+
+    public LtcEngine(TangemContext context) throws Exception {
+        super(context);
+        if (context.getCoinData() == null) {
+            coinData = new BtcData();
+            context.setCoinData(coinData);
+        } else if (context.getCoinData() instanceof BtcData) {
+            coinData = (BtcData) context.getCoinData();
+        } else {
+            throw new Exception("Invalid type of Blockchain data for LtcEngine");
+        }
+    }
+
+    public LtcEngine() {
+        super();
+    }
+
+    private static int getDecimals() {
+        return 8;
+    }
+
+
+    private void checkBlockchainDataExists() throws Exception {
+        if (coinData == null) throw new Exception("No blockchain data");
+    }
+
+    @Override
+    public boolean awaitingConfirmation() {
+        if (coinData == null) return false;
+        return coinData.getBalanceUnconfirmed() != 0;
+    }
+
+    @Override
+    public String getBalanceHTML() {
+        Amount balance = getBalance();
+        if (balance != null) {
+            return balance.toDescriptionString(getDecimals());
+        } else {
+            return "";
+        }
+    }
+
+    @Override
+    public String getBalanceCurrency() {
+        return "LTC";
+    }
+
+    @Override
+    public String getOfflineBalanceHTML() {
+        InternalAmount offlineInternalAmount = convertToInternalAmount(ctx.getCard().getOfflineBalance());
+        Amount offlineAmount = convertToAmount(offlineInternalAmount);
+        return offlineAmount.toDescriptionString(getDecimals());
+    }
+
+    @Override
+    public boolean isBalanceNotZero() {
+        if (coinData == null) return false;
+        if (coinData.getBalanceInInternalUnits() == null) return false;
+        return coinData.getBalanceInInternalUnits().notZero();
+    }
+
+    @Override
+    public boolean hasBalanceInfo() {
+        if (coinData == null) return false;
+        return coinData.hasBalanceInfo();
+    }
+
+
+    @Override
+    public boolean isExtractPossible() {
+        if (!hasBalanceInfo()) {
+            ctx.setMessage(R.string.cannot_obtain_data_from_blockchain);
+        } else if (!isBalanceNotZero()) {
+            ctx.setMessage(R.string.wallet_empty);
+        } else if (awaitingConfirmation()) {
+            ctx.setMessage(R.string.please_wait_while_previous);
+        } else if (coinData.getUnspentTransactions().size() == 0) {
+            ctx.setMessage(R.string.please_wait_for_confirmation);
+        } else {
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public String getFeeCurrency() {
+        return "LTC";
+    }
+
+    @Override
+    public boolean validateAddress(String address) {
+        if (address == null || address.isEmpty()) {
+            return false;
+        }
+
+        if (address.length() < 25) {
+            return false;
+        }
+
+        if (address.length() > 35) {
+            return false;
+        }
+
+        if (!address.startsWith("L") && !address.startsWith("M")) {
+            return false;
+        }
+
+        byte[] decAddress = Base58.decodeBase58(address);
+
+        if (decAddress == null || decAddress.length == 0) {
+            return false;
+        }
+
+        byte[] rip = new byte[21];
+        for (int i = 0; i < 21; ++i) {
+            rip[i] = decAddress[i];
+        }
+
+        byte[] kcv = CryptoUtil.doubleSha256(rip);
+
+        for (int i = 0; i < 4; ++i) {
+            if (kcv[i] != decAddress[21 + i])
+                return false;
+        }
+
+        return true;
+    }
+
+
+    @Override
+    public boolean isNeedCheckNode() {
+        return true;
+    }
+
+    @Override
+    public Uri getShareWalletUriExplorer() {
+        return Uri.parse((ctx.getBlockchain() == Blockchain.Bitcoin ? "https://blockchain.info/address/" : "https://testnet.blockchain.info/address/") + ctx.getCoinData().getWallet());
+    }
+
+    @Override
+    public Uri getShareWalletUri() {
+        if (ctx.getCard().getDenomination() != null) {
+            return Uri.parse("bitcoin:" + ctx.getCoinData().getWallet() + "?amount=" + convertToAmount(convertToInternalAmount(ctx.getCard().getDenomination())).toValueString(8));
+        } else {
+            return Uri.parse("bitcoin:" + ctx.getCoinData().getWallet());
+        }
+    }
+
+    @Override
+    public InputFilter[] getAmountInputFilters() {
+        return new InputFilter[]{new DecimalDigitsInputFilter(getDecimals())};
+    }
+
+    @Override
+    public boolean checkNewTransactionAmount(Amount amount) {
+        if (coinData == null) return false;
+        if (amount.compareTo(convertToAmount(coinData.getBalanceInInternalUnits())) > 0) {
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    public boolean checkNewTransactionAmountAndFee(Amount amountValue, Amount feeValue, Boolean isIncludeFee) {
+        InternalAmount fee;
+        InternalAmount amount;
+
+        try {
+            checkBlockchainDataExists();
+            amount = convertToInternalAmount(amountValue);
+            fee = convertToInternalAmount(feeValue);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+
+        if (fee == null || amount == null)
+            return false;
+
+        if (fee.isZero() || amount.isZero())
+            return false;
+
+        if (isIncludeFee && (amount.compareTo(coinData.getBalanceInInternalUnits()) > 0 || amount.compareTo(fee) < 0))
+            return false;
+
+        if (!isIncludeFee && amount.add(fee).compareTo(coinData.getBalanceInInternalUnits()) > 0)
+            return false;
+
+        return true;
+    }
+
+    @Override
+    public boolean validateBalance(BalanceValidator balanceValidator) {
+        if (((ctx.getCard().getOfflineBalance() == null) && !ctx.getCoinData().isBalanceReceived()) || (!ctx.getCoinData().isBalanceReceived() && (ctx.getCard().getRemainingSignatures() != ctx.getCard().getMaxSignatures()))) {
+            balanceValidator.setScore(0);
+            balanceValidator.setFirstLine("Unknown balance");
+            balanceValidator.setSecondLine("Balance cannot be verified. Swipe down to refresh.");
+            return false;
+        }
+
+        // Workaround before new back-end
+//        if (card.getRemainingSignatures() == card.getMaxSignatures()) {
+//            firstLine = "Verified balance";
+//            secondLine = "Balance confirmed in blockchain. ";
+//            secondLine += "Verified note identity. ";
+//            return;
+//        }
+
+        if (coinData.getBalanceUnconfirmed() != 0) {
+            balanceValidator.setScore(0);
+            balanceValidator.setFirstLine("Transaction in progress");
+            balanceValidator.setSecondLine("Wait for confirmation in blockchain");
+            return false;
+        }
+
+        if (coinData.isBalanceReceived() && coinData.isBalanceEqual()) {
+            balanceValidator.setScore(100);
+            balanceValidator.setFirstLine("Verified balance");
+            balanceValidator.setSecondLine("Balance confirmed in blockchain");
+            if (coinData.getBalanceInInternalUnits().isZero()) {
+                balanceValidator.setFirstLine("Empty wallet");
+                balanceValidator.setSecondLine("");
+            }
+        }
+
+        // rule 4 TODO: need to check SignedHashed against number of outputs in blockchain
+//        if((card.getRemainingSignatures() != card.getMaxSignatures()) && card.getBalance() != 0)
+//        {
+//            score = 80;
+//            firstLine = "Unguaranteed balance";
+//            secondLine = "Potential unsent transaction. Redeem immediately if accept. ";
+//            return;
+//        }
+
+        if ((ctx.getCard().getOfflineBalance() != null) && !coinData.isBalanceReceived() && (ctx.getCard().getRemainingSignatures() == ctx.getCard().getMaxSignatures()) && coinData.getBalanceInInternalUnits().notZero()) {
+            balanceValidator.setScore(80);
+            balanceValidator.setFirstLine("Verified offline balance");
+            balanceValidator.setSecondLine("Can't obtain balance from blockchain. Restore internet connection to be more confident. ");
+        }
+
+//            if(card.getFailedBalanceRequestCounter()!=0) {
+//                score -= 5 * card.getFailedBalanceRequestCounter();
+//                secondLine += "Not all nodes have returned balance. Swipe down or tap again. ";
+//                if(score <= 0)
+//                    return;
+//            }
+
+        //
+//            if(card.isBalanceReceived() && !card.isBalanceEqual()) {
+//                score = 0;
+//                firstLine = "Disputed balance";
+//                secondLine += " Cannot obtain trusted balance at the moment. Try to tap and check this banknote later.";
+//                return;
+//            }
+
+        return true;
+    }
+
+    @Override
+    public Amount getBalance() {
+        if (!hasBalanceInfo()) return null;
+        return convertToAmount(coinData.getBalanceInInternalUnits());
+    }
+
+    @Override
+    public String evaluateFeeEquivalent(String fee) {
+        if (!coinData.getAmountEquivalentDescriptionAvailable()) return "";
+        try {
+            Amount feeAmount = new Amount(fee, getFeeCurrency());
+            return feeAmount.toEquivalentString(coinData.getRate());
+        } catch (Exception e) {
+            return "";
+        }
+    }
+
+    @Override
+    public String getBalanceEquivalent() {
+        if (coinData == null || !coinData.getAmountEquivalentDescriptionAvailable()) return "";
+        Amount balance = getBalance();
+        if (balance == null) return "";
+        return balance.toEquivalentString(coinData.getRate());
+    }
+
+    @Override
+    public String calculateAddress(byte[] pkUncompressed) throws NoSuchProviderException, NoSuchAlgorithmException {
+        byte netSelectionByte = (byte) 0x30;
+
+        byte hash1[] = Util.calculateSHA256(pkUncompressed);
+        byte hash2[] = Util.calculateRIPEMD160(hash1);
+
+        ByteBuffer BB = ByteBuffer.allocate(hash2.length + 1);
+
+        BB.put(netSelectionByte);
+        BB.put(hash2);
+
+        byte hash3[] = Util.calculateSHA256(BB.array());
+        byte hash4[] = Util.calculateSHA256(hash3);
+
+        BB = ByteBuffer.allocate(hash2.length + 5);
+        BB.put(netSelectionByte); //BB.put((byte) 0x6f);
+        BB.put(hash2);
+        BB.put(hash4[0]);
+        BB.put(hash4[1]);
+        BB.put(hash4[2]);
+        BB.put(hash4[3]);
+
+        return org.bitcoinj.core.Base58.encode(BB.array());
+    }
+
+    @Override
+    public Amount convertToAmount(InternalAmount internalAmount) {
+        BigDecimal d = internalAmount.divide(new BigDecimal("100000000"));
+        return new Amount(d, getBalanceCurrency());
+    }
+
+    @Override
+    public Amount convertToAmount(String strAmount, String currency) {
+        return new Amount(strAmount, currency);
+    }
+
+    @Override
+    public InternalAmount convertToInternalAmount(Amount amount) throws Exception {
+        BigDecimal d = amount.multiply(new BigDecimal("100000000"));
+        return new InternalAmount(d, "Satoshi");
+    }
+
+    @Override
+    public InternalAmount convertToInternalAmount(byte[] bytes) {
+        if (bytes == null) return null;
+        byte[] reversed = new byte[bytes.length];
+        for (int i = 0; i < bytes.length; i++) reversed[i] = bytes[bytes.length - i - 1];
+        return new InternalAmount(Util.byteArrayToLong(reversed), "Satoshi");
+    }
+
+    @Override
+    public byte[] convertToByteArray(InternalAmount internalAmount) throws Exception {
+        byte[] bytes = Util.longToByteArray(internalAmount.longValueExact());
+        byte[] reversed = new byte[bytes.length];
+        for (int i = 0; i < bytes.length; i++) reversed[i] = bytes[bytes.length - i - 1];
+        return reversed;
+    }
+
+    @Override
+    public CoinData createCoinData() {
+        return new BtcData();
+    }
+
+    @Override
+    public String getUnspentInputsDescription() {
+        return coinData.getUnspentInputsDescription();
+    }
+
+    @Override
+    public SignTask.PaymentToSign constructPayment(Amount amountValue, Amount feeValue, boolean IncFee, String targetAddress) throws Exception {
+        final ArrayList<UnspentOutputInfo> unspentOutputs;
+        checkBlockchainDataExists();
+
+        String myAddress = ctx.getCoinData().getWallet();
+        byte[] pbKey = ctx.getCard().getWalletPublicKey();
+
+        // Build script for our address
+        List<BtcData.UnspentTransaction> rawTxList = coinData.getUnspentTransactions();
+        byte[] outputScriptWeAreAbleToSpend = Transaction.Script.buildOutput(myAddress).bytes;
+
+        // Collect unspent
+        unspentOutputs = BTCUtils.getOutputs(rawTxList, outputScriptWeAreAbleToSpend);
+
+        long fullAmount = 0;
+        for (int i = 0; i < unspentOutputs.size(); ++i) {
+            fullAmount += unspentOutputs.get(i).value;
+        }
+
+        long fees = convertToInternalAmount(feeValue).longValueExact();
+        long amount = convertToInternalAmount(amountValue).longValueExact();
+        long change = fullAmount - amount;
+        if (IncFee) {
+            amount = amount - fees;
+        } else {
+            change = change - fees;
+        }
+
+        final long amountFinal=amount;
+        final long changeFinal=change;
+
+        if (amount + fees > fullAmount) {
+            throw new CardProtocol.TangemException_WrongAmount(String.format("Balance (%d) < change (%d) + amount (%d)", fullAmount, change, amount));
+        }
+
+        final byte[][] txForSign = new byte[unspentOutputs.size()][];
+        final byte[][] bodyDoubleHash = new byte[unspentOutputs.size()][];
+        final byte[][] bodyHash= new byte[unspentOutputs.size()][];
+
+        for (int i = 0; i < unspentOutputs.size(); ++i) {
+            txForSign[i] = BTCUtils.buildTXForSign(myAddress, targetAddress, myAddress, unspentOutputs, i, amount, change);
+            bodyHash[i] = Util.calculateSHA256(txForSign[i]);
+            bodyDoubleHash[i] = Util.calculateSHA256(bodyHash[i]);
+        }
+
+        return new SignTask.PaymentToSign() {
+
+            @Override
+            public boolean isSigningMethodSupported(TangemCard.SigningMethod signingMethod) {
+                return signingMethod==TangemCard.SigningMethod.Sign_Hash || signingMethod==TangemCard.SigningMethod.Sign_Raw;
+            }
+
+            @Override
+            public byte[][] getHashesToSign() throws Exception {
+                byte[][] dataForSign=new byte[unspentOutputs.size()][];
+                if (txForSign.length > 10) throw new Exception("To much hashes in one transaction!");
+                for (int i = 0; i < unspentOutputs.size(); ++i) {
+                    dataForSign[i] = bodyDoubleHash[i];
+                }
+                return dataForSign;
+            }
+
+            @Override
+            public byte[] getRawDataToSign() throws Exception {
+                ByteArrayOutputStream bs = new ByteArrayOutputStream();
+                for (int i = 0; i < txForSign.length; i++) {
+                    if (i != 0 && txForSign[0].length != txForSign[i].length)
+                        throw new Exception("Hashes length must be identical!");
+                    bs.write(txForSign[i]);
+                }
+
+                return bs.toByteArray();
+            }
+
+            @Override
+            public String getHashAlgToSign() {
+                return "sha-256x2";
+            }
+
+            @Override
+            public byte[] getIssuerTransactionSignature(byte[] dataToSignByIssuer) throws Exception {
+                throw new Exception("Issuer validation not supported!");
+            }
+
+            @Override
+            public void onSignCompleted(byte[] signFromCard) throws Exception {
+                for (int i = 0; i < unspentOutputs.size(); ++i) {
+                    BigInteger r = new BigInteger(1, Arrays.copyOfRange(signFromCard, i * 64, 32 + i * 64));
+                    BigInteger s = new BigInteger(1, Arrays.copyOfRange(signFromCard, 32 + i * 64, 64 + i * 64));
+                    s = CryptoUtil.toCanonicalised(s);
+
+                    unspentOutputs.get(i).scriptForBuild = DerEncodingUtil.packSignDer(r, s, pbKey);
+                }
+
+                byte[] txForSend=BTCUtils.buildTXForSend(targetAddress, myAddress, unspentOutputs, amountFinal, changeFinal);
+                notifyOnNeedSendPayment(txForSend);
+            }
+        };
+    }
+
+//    @Override
+//    public byte[] sign(Amount feeValue, Amount amountValue, boolean IncFee, String targetAddress, CardProtocol protocol) throws Exception {
+//
+//        checkBlockchainDataExists();
+//
+//        String myAddress = ctx.getCoinData().getWallet();
+//        byte[] pbKey = ctx.getCard().getWalletPublicKey();
+//
+//        // Build script for our address
+//        List<BtcData.UnspentTransaction> rawTxList = coinData.getUnspentTransactions();
+//        byte[] outputScriptWeAreAbleToSpend = Transaction.Script.buildOutput(myAddress).bytes;
+//
+//        // Collect unspent
+//        ArrayList<UnspentOutputInfo> unspentOutputs = BTCUtils.getOutputs(rawTxList, outputScriptWeAreAbleToSpend);
+//
+//        long fullAmount = 0;
+//        for (int i = 0; i < unspentOutputs.size(); ++i) {
+//            fullAmount += unspentOutputs.get(i).value;
+//        }
+//
+//
+//        long fees = convertToInternalAmount(feeValue).longValueExact();
+//        long amount = convertToInternalAmount(amountValue).longValueExact();
+//        long change = fullAmount - amount;
+//        if (IncFee) {
+//            amount = amount - fees;
+//        } else {
+//            change = change - fees;
+//        }
+//
+//        if (amount + fees > fullAmount) {
+//            throw new CardProtocol.TangemException_WrongAmount(String.format("Balance (%d) < change (%d) + amount (%d)", fullAmount, change, amount));
+//        }
+//
+//        byte[][] dataForSign = new byte[unspentOutputs.size()][];
+//
+//        for (int i = 0; i < unspentOutputs.size(); ++i) {
+//            byte[] newTX = BTCUtils.buildTXForSign(myAddress, targetAddress, myAddress, unspentOutputs, i, amount, change);
+//
+//            byte[] hashData = Util.calculateSHA256(newTX);
+//            byte[] doubleHashData = Util.calculateSHA256(hashData);
+//
+//            unspentOutputs.get(i).bodyDoubleHash = doubleHashData;
+//            unspentOutputs.get(i).bodyHash = hashData;
+//
+//            if (ctx.getCard().getSigningMethod() == TangemCard.SigningMethod.Sign_Raw || ctx.getCard().getSigningMethod() == TangemCard.SigningMethod.Sign_Raw_Validated_By_Issuer) {
+//                dataForSign[i] = newTX;
+//            } else {
+//                dataForSign[i] = doubleHashData;
+//            }
+//        }
+//
+//        byte[] signFromCard;
+//        if (ctx.getCard().getSigningMethod() == TangemCard.SigningMethod.Sign_Raw || ctx.getCard().getSigningMethod() == TangemCard.SigningMethod.Sign_Raw_Validated_By_Issuer) {
+//            ByteArrayOutputStream bs = new ByteArrayOutputStream();
+//            if (dataForSign.length > 10) throw new Exception("To much hashes in one transaction!");
+//            for (int i = 0; i < dataForSign.length; i++) {
+//                if (i != 0 && dataForSign[0].length != dataForSign[i].length)
+//                    throw new Exception("Hashes length must be identical!");
+//                bs.write(dataForSign[i]);
+//            }
+//            signFromCard = protocol.run_SignRaw(PINStorage.getPIN2(), "sha-256x2",bs.toByteArray(),null,null,null).getTLV(TLV.Tag.TAG_Signature).Value;
+//        } else {
+//            //ctx.getCard().getSigningMethod() == TangemCard.SigningMethod.Sign_Hash_Validated_By_Issuer, null, ctx.getCard().getIssuer()
+//            signFromCard = protocol.run_SignHashes(PINStorage.getPIN2(), dataForSign, null, null, null).getTLV(TLV.Tag.TAG_Signature).Value;
+//            // TODO slice signFromCard to hashes.length parts
+//        }
+//
+//        for (int i = 0; i < unspentOutputs.size(); ++i) {
+//            BigInteger r = new BigInteger(1, Arrays.copyOfRange(signFromCard, i * 64, 32 + i * 64));
+//            BigInteger s = new BigInteger(1, Arrays.copyOfRange(signFromCard, 32 + i * 64, 64 + i * 64));
+//            s = CryptoUtil.toCanonicalised(s);
+//
+//            unspentOutputs.get(i).scriptForBuild = DerEncodingUtil.packSignDer(r, s, pbKey);
+//        }
+//
+//        return BTCUtils.buildTXForSend(targetAddress, myAddress, unspentOutputs, amount, change);
+//    }
+
+}

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

@@ -107,7 +107,7 @@ class ConfirmPaymentActivity : AppCompatActivity(), NfcAdapter.ReaderCallback {
 
             requestInfura(ServerApiInfura.INFURA_ETH_GAS_PRICE)
 
-        } else if (ctx.blockchain == Blockchain.BitcoinCash) {
+        } else if (ctx.blockchain == Blockchain.BitcoinCash || ctx.blockchain == Blockchain.Litecoin) {
             rgFee.isEnabled = false
 
             progressBar.visibility = View.VISIBLE
@@ -229,7 +229,7 @@ class ConfirmPaymentActivity : AppCompatActivity(), NfcAdapter.ReaderCallback {
                         }
                         fee = fee.setScale(8, RoundingMode.DOWN)
 
-                        var feeAmount: CoinEngine.Amount = CoinEngine.Amount(fee, "BCH")
+                        var feeAmount: CoinEngine.Amount = CoinEngine.Amount(fee, ctx.blockchain.currency)
                         minFee = feeAmount
                         normalFee = feeAmount
                         maxFee = feeAmount

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

@@ -808,7 +808,7 @@ class LoadedWallet : Fragment(), NfcAdapter.ReaderCallback, CardProtocol.Notific
         requestVerifyAndGetInfo()
 
         // Bitcoin
-        if (ctx.blockchain == Blockchain.Bitcoin || ctx.blockchain == Blockchain.BitcoinTestNet) {
+        if (ctx.blockchain == Blockchain.Bitcoin || ctx.blockchain == Blockchain.BitcoinTestNet || ctx.blockchain == Blockchain.Litecoin) {
             ctx.coinData.setIsBalanceEqual(true)
 
             requestElectrum(ElectrumRequest.checkBalance(ctx.coinData!!.wallet))