From 83ac9c0db3d116d60d45a135e19447eed080b9ee Mon Sep 17 00:00:00 2001
From: Khushal <khushal2004a@gmail.com>
Date: Sun, 1 Mar 2026 18:39:58 +0530
Subject: [PATCH] feat: multimint sends using cdk

---
 1                                             |  33 ++
 App.tsx                                       |   7 +
 .../com/zeus/cashudevkit/CashuDevKitModule.kt | 110 +++-
 cashu-cdk/CashuDevKit.ts                      |  44 ++
 cashu-cdk/types.ts                            |  21 +
 components/EcashMintPicker.tsx                | 207 ++++++-
 ios/CashuDevKit/CashuDevKitModule.m           |  11 +
 ios/CashuDevKit/CashuDevKitModule.swift       | 106 +++-
 locales/en.json                               |   4 +
 stores/CashuStore.ts                          | 473 +++++++++++++++-
 stores/SettingsStore.ts                       |   2 +
 utils/CashuUtils.ts                           |  23 +
 views/Cashu/CashuPaymentRequest.tsx           | 207 ++++++-
 views/Cashu/CashuSendingLightning.tsx         |  17 +-
 views/Cashu/LegacySeedRecovery.tsx            |   1 +
 .../LightningAddressSettings.tsx              |   6 +-
 views/Cashu/Mints.tsx                         | 214 ++++++--
 views/Cashu/MultimintPayment.tsx              | 516 ++++++++++++++++++
 views/Cashu/ReceiveEcash.tsx                  |   2 +
 views/Settings/EcashSettings.tsx              |  78 ++-
 20 files changed, 1975 insertions(+), 107 deletions(-)
 create mode 100644 1
 create mode 100644 views/Cashu/MultimintPayment.tsx

diff --git a/1 b/1
new file mode 100644
index 000000000..097c32cf3
--- /dev/null
+++ b/1
@@ -0,0 +1,33 @@
+pick 09a58a0b5 # docs: add comment explaining amountInput usage in keypad components
+fixup bc2a22a2b # fix: nit
+
+# Rebase 15aee7d98..bc2a22a2b onto 15aee7d98 (2 commands)
+#
+# Commands:
+# p, pick <commit> = use commit
+# r, reword <commit> = use commit, but edit the commit message
+# e, edit <commit> = use commit, but stop for amending
+# s, squash <commit> = use commit, but meld into previous commit
+# f, fixup [-C | -c] <commit> = like "squash" but keep only the previous
+#                    commit's log message, unless -C is used, in which case
+#                    keep only this commit's message; -c is same as -C but
+#                    opens the editor
+# x, exec <command> = run command (the rest of the line) using shell
+# b, break = stop here (continue rebase later with 'git rebase --continue')
+# d, drop <commit> = remove commit
+# l, label <label> = label current HEAD with a name
+# t, reset <label> = reset HEAD to a label
+# m, merge [-C <commit> | -c <commit>] <label> [# <oneline>]
+#         create a merge commit using the original merge commit's
+#         message (or the oneline, if no original merge commit was
+#         specified); use -c <commit> to reword the commit message
+# u, update-ref <ref> = track a placeholder for the <ref> to be updated
+#                       to this position in the new commits. The <ref> is
+#                       updated at the end of the rebase
+#
+# These lines can be re-ordered; they are executed from top to bottom.
+#
+# If you remove a line here THAT COMMIT WILL BE LOST.
+#
+# However, if you remove everything, the rebase will be aborted.
+#
diff --git a/App.tsx b/App.tsx
index 8b7ee533c..4c3ae3975 100644
--- a/App.tsx
+++ b/App.tsx
@@ -253,6 +253,7 @@ import CashuInvoice from './views/Cashu/CashuInvoice';
 import CashuPayment from './views/Cashu/CashuPayment';
 import CashuPaymentRequest from './views/Cashu/CashuPaymentRequest';
 import CashuSendingLightning from './views/Cashu/CashuSendingLightning';
+import MultimintPayment from './views/Cashu/MultimintPayment';
 import Mint from './views/Cashu/Mint';
 import Mints from './views/Cashu/Mints';
 import AddMint from './views/Cashu/AddMint';
@@ -1611,6 +1612,12 @@ export default class App extends React.PureComponent {
                                                                     CashuSendingLightning
                                                                 }
                                                             />
+                                                            <Stack.Screen
+                                                                name="MultimintPayment" // @ts-ignore:next-line
+                                                                component={
+                                                                    MultimintPayment
+                                                                }
+                                                            />
                                                             <Stack.Screen
                                                                 name="Mint" // @ts-ignore:next-line
                                                                 component={Mint}
diff --git a/android/app/src/main/java/com/zeus/cashudevkit/CashuDevKitModule.kt b/android/app/src/main/java/com/zeus/cashudevkit/CashuDevKitModule.kt
index 2589e1e5a..d2e13580d 100644
--- a/android/app/src/main/java/com/zeus/cashudevkit/CashuDevKitModule.kt
+++ b/android/app/src/main/java/com/zeus/cashudevkit/CashuDevKitModule.kt
@@ -70,6 +70,41 @@ class CashuDevKitModule(private val reactContext: ReactApplicationContext) :
         )
     }
 
+    private fun readPositiveLong(json: JSONObject, key: String): Long {
+        return when (val raw = json.opt(key)) {
+            is Number -> raw.toLong()
+            is String -> raw.toLongOrNull() ?: 0L
+            else -> 0L
+        }.coerceAtLeast(0L)
+    }
+
+    private fun parseMeltOptions(optionsJson: String?): MeltOptions? {
+        if (optionsJson.isNullOrBlank()) return null
+
+        return try {
+            val parsed = JSONObject(optionsJson)
+
+            parsed.optJSONObject("mpp")?.let { mpp ->
+                val amount = readPositiveLong(mpp, "amount")
+                if (amount > 0) {
+                    return MeltOptions.Mpp(Amount(amount.toULong()))
+                }
+            }
+
+            parsed.optJSONObject("amountless")?.let { amountless ->
+                val amountMsat = readPositiveLong(amountless, "amount_msat")
+                if (amountMsat > 0) {
+                    return MeltOptions.Amountless(Amount(amountMsat.toULong()))
+                }
+            }
+
+            null
+        } catch (e: Exception) {
+            Log.w(TAG, "parseMeltOptions: invalid options JSON", e)
+            null
+        }
+    }
+
     /**
      * Returns the initialized wallet or rejects with NO_WALLET error and returns null
      */
@@ -196,6 +231,16 @@ class CashuDevKitModule(private val reactContext: ReactApplicationContext) :
         }
     }
 
+    private fun encodeTransferResult(result: TransferResult): JSONObject {
+        return JSONObject().apply {
+            put("amount_sent", result.amountSent.value)
+            put("amount_received", result.amountReceived.value)
+            put("fees_paid", result.feesPaid.value)
+            put("source_balance_after", result.sourceBalanceAfter.value)
+            put("target_balance_after", result.targetBalanceAfter.value)
+        }
+    }
+
     private fun encodeProof(proof: Proof): JSONObject {
         return JSONObject().apply {
             put("amount", proof.amount.value.toLong())
@@ -816,7 +861,8 @@ class CashuDevKitModule(private val reactContext: ReactApplicationContext) :
         scope.launch {
             try {
                 val url = MintUrl(mintUrl)
-                val quote = wallet!!.meltQuote(url, request, null)
+                val options = parseMeltOptions(optionsJson)
+                val quote = wallet!!.meltQuote(url, request, options)
 
                 withContext(Dispatchers.Main) {
                     promise.resolve(encodeMeltQuote(quote).toString())
@@ -890,6 +936,65 @@ class CashuDevKitModule(private val reactContext: ReactApplicationContext) :
         }
     }
 
+    @ReactMethod
+    fun transferExactReceive(sourceMint: String, targetMint: String, amount: Double, promise: Promise) {
+        val wallet = getInitializedWallet(promise) ?: return
+
+        scope.launch {
+            try {
+                val sourceUrl = MintUrl(sourceMint)
+                val targetUrl = MintUrl(targetMint)
+                val transferMode = TransferMode.ExactReceive(Amount(amount.toLong().toULong()))
+
+                val result = wallet.transfer(sourceUrl, targetUrl, transferMode)
+
+                withContext(Dispatchers.Main) {
+                    promise.resolve(encodeTransferResult(result).toString())
+                }
+            } catch (e: FfiException) {
+                val (code, message) = mapFfiException(e)
+                Log.e(TAG, "transferExactReceive error: $message", e)
+                withContext(Dispatchers.Main) {
+                    promise.reject(code, message, e)
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "transferExactReceive error", e)
+                withContext(Dispatchers.Main) {
+                    promise.reject("TRANSFER_ERROR", e.message, e)
+                }
+            }
+        }
+    }
+
+    @ReactMethod
+    fun transferFullBalance(sourceMint: String, targetMint: String, promise: Promise) {
+        val wallet = getInitializedWallet(promise) ?: return
+
+        scope.launch {
+            try {
+                val sourceUrl = MintUrl(sourceMint)
+                val targetUrl = MintUrl(targetMint)
+
+                val result = wallet.transfer(sourceUrl, targetUrl, TransferMode.FullBalance)
+
+                withContext(Dispatchers.Main) {
+                    promise.resolve(encodeTransferResult(result).toString())
+                }
+            } catch (e: FfiException) {
+                val (code, message) = mapFfiException(e)
+                Log.e(TAG, "transferFullBalance error: $message", e)
+                withContext(Dispatchers.Main) {
+                    promise.reject(code, message, e)
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "transferFullBalance error", e)
+                withContext(Dispatchers.Main) {
+                    promise.reject("TRANSFER_ERROR", e.message, e)
+                }
+            }
+        }
+    }
+
     // ========================================================================
     // Token Operations
     // ========================================================================
@@ -1332,7 +1437,8 @@ class CashuDevKitModule(private val reactContext: ReactApplicationContext) :
         scope.launch {
             try {
                 val url = MintUrl(mintUrl)
-                val quote = wallet!!.meltQuote(url, request, null)
+                val options = parseMeltOptions(optionsJson)
+                val quote = wallet!!.meltQuote(url, request, options)
 
                 withContext(Dispatchers.Main) {
                     promise.resolve(encodeMeltQuote(quote).toString())
diff --git a/cashu-cdk/CashuDevKit.ts b/cashu-cdk/CashuDevKit.ts
index fb609e66f..311e75b8e 100644
--- a/cashu-cdk/CashuDevKit.ts
+++ b/cashu-cdk/CashuDevKit.ts
@@ -15,6 +15,7 @@ import {
     CDKMintQuote,
     CDKMeltQuote,
     CDKMelted,
+    CDKTransferResult,
     CDKSpendingConditions,
     CDKSendKind,
     CDKSendOptions,
@@ -433,6 +434,49 @@ class CashuDevKit {
         }
     }
 
+    /**
+     * Transfer an exact amount to a target mint (target receives requested amount)
+     * @param sourceMint - Source mint URL
+     * @param targetMint - Target mint URL
+     * @param amount - Amount to receive at target (sats)
+     */
+    async transferExactReceive(
+        sourceMint: string,
+        targetMint: string,
+        amount: number
+    ): Promise<CDKTransferResult> {
+        try {
+            const json = await CashuDevKitModule.transferExactReceive(
+                sourceMint,
+                targetMint,
+                amount
+            );
+            return JSON.parse(json);
+        } catch (error) {
+            throw mapCDKError(error);
+        }
+    }
+
+    /**
+     * Transfer full available balance from source mint to target mint
+     * @param sourceMint - Source mint URL
+     * @param targetMint - Target mint URL
+     */
+    async transferFullBalance(
+        sourceMint: string,
+        targetMint: string
+    ): Promise<CDKTransferResult> {
+        try {
+            const json = await CashuDevKitModule.transferFullBalance(
+                sourceMint,
+                targetMint
+            );
+            return JSON.parse(json);
+        } catch (error) {
+            throw mapCDKError(error);
+        }
+    }
+
     // ========================================================================
     // Token Operations (Send/Receive)
     // ========================================================================
diff --git a/cashu-cdk/types.ts b/cashu-cdk/types.ts
index c3cf69da2..790ac6229 100644
--- a/cashu-cdk/types.ts
+++ b/cashu-cdk/types.ts
@@ -109,6 +109,18 @@ export interface CDKMelted {
     fee_paid: number;
 }
 
+// ============================================================================
+// Multi-mint Transfer Types
+// ============================================================================
+
+export interface CDKTransferResult {
+    amount_sent: number;
+    amount_received: number;
+    fees_paid: number;
+    source_balance_after: number;
+    target_balance_after: number;
+}
+
 // ============================================================================
 // Spending Conditions (P2PK)
 // ============================================================================
@@ -279,6 +291,15 @@ export interface CashuDevKitNativeModule {
     ): Promise<string>;
     checkMeltQuote(mintUrl: string, quoteId: string): Promise<string>;
     melt(mintUrl: string, quoteId: string): Promise<string>;
+    transferExactReceive(
+        sourceMint: string,
+        targetMint: string,
+        amount: number
+    ): Promise<string>;
+    transferFullBalance(
+        sourceMint: string,
+        targetMint: string
+    ): Promise<string>;
 
     // Token Operations
     prepareSend(
diff --git a/components/EcashMintPicker.tsx b/components/EcashMintPicker.tsx
index c8f72cf42..3e86ac025 100644
--- a/components/EcashMintPicker.tsx
+++ b/components/EcashMintPicker.tsx
@@ -9,6 +9,7 @@ import MintAvatar from './MintAvatar';
 import { Row } from './layout/Row';
 
 import CashuStore from '../stores/CashuStore';
+import SettingsStore from '../stores/SettingsStore';
 
 import { localeString } from '../utils/LocaleUtils';
 import { themeColor } from '../utils/ThemeUtils';
@@ -20,13 +21,15 @@ interface EcashMintPickerProps {
     title?: string;
     CashuStore?: CashuStore;
     navigation: NativeStackNavigationProp<any, any>;
+    SettingsStore?: SettingsStore;
     hideAmount?: boolean;
     disabled?: boolean;
     disableRandom?: boolean;
     overrideMintUrl?: string;
+    isReceiveView?: boolean;
 }
 
-@inject('CashuStore')
+@inject('CashuStore', 'SettingsStore')
 @observer
 export default class EcashMintPicker extends React.Component<
     EcashMintPickerProps,
@@ -35,20 +38,25 @@ export default class EcashMintPicker extends React.Component<
     render() {
         const {
             CashuStore,
+            SettingsStore,
             hideAmount,
             disabled,
             disableRandom,
             navigation,
-            overrideMintUrl
+            overrideMintUrl,
+            isReceiveView
         } = this.props;
         const {
             cashuWallets,
             mintUrls,
             selectedMintUrl,
+            selectedMintUrls,
             mintInfos,
             mintBalances,
             randomizeMintSelection
         } = CashuStore!!;
+        const multiMintEnabled =
+            !!SettingsStore?.settings?.ecash?.enableMultiMint;
 
         const displayMintUrl = overrideMintUrl || selectedMintUrl;
         const showRandom =
@@ -57,7 +65,7 @@ export default class EcashMintPicker extends React.Component<
             !overrideMintUrl &&
             mintUrls.length > 1;
 
-        let mints: any = {};
+        const mints: any = {};
         mintUrls.forEach((mintUrl) => {
             const wallet = cashuWallets[mintUrl];
             const mintInfo = mintInfos[mintUrl];
@@ -69,11 +77,187 @@ export default class EcashMintPicker extends React.Component<
             };
         });
 
+        const getRow = (mintUrl: string, key: string | number = mintUrl) => (
+            <Row
+                key={key}
+                style={{
+                    height: 42,
+                    alignItems: 'center',
+                    paddingRight: 34,
+                    marginBottom: 0,
+                    backgroundColor: 'transparent'
+                }}
+            >
+                <MintAvatar
+                    iconUrl={mints[mintUrl]?.icon_url}
+                    name={mints[mintUrl]?.name}
+                    size="small"
+                    style={{
+                        marginRight: 10,
+                        flexShrink: 0
+                    }}
+                />
+                <Text
+                    style={{
+                        ...styles.text,
+                        color: mints[mintUrl]?.errorConnecting
+                            ? themeColor('warning')
+                            : themeColor('text'),
+                        flex: 1,
+                        flexShrink: 1,
+                        minWidth: 0
+                    }}
+                    numberOfLines={1}
+                    ellipsizeMode="tail"
+                >
+                    {mints[mintUrl]?.name
+                        ? mints[mintUrl].name
+                        : localeString('cashu.tapToConfigure.short')}
+                </Text>
+                {!hideAmount && (
+                    <View
+                        style={{
+                            marginRight: 8,
+                            flexShrink: 0
+                        }}
+                    >
+                        <Amount sats={mints[mintUrl]?.mintBalance} sensitive />
+                    </View>
+                )}
+            </Row>
+        );
+
+        const selectedMints = selectedMintUrls || [];
+
+        if (multiMintEnabled && !isReceiveView) {
+            if (selectedMints.length === 0) {
+                return (
+                    <View style={{ flex: 1, flexDirection: 'row' }}>
+                        <TouchableOpacity
+                            onPress={() => navigation.navigate('Mints')}
+                            style={{
+                                opacity: disabled ? 0.25 : 1,
+                                backgroundColor: themeColor('secondary'),
+                                ...styles.field
+                            }}
+                        >
+                            <Row
+                                style={{
+                                    height: 42,
+                                    alignItems: 'center',
+                                    paddingRight: 34,
+                                    backgroundColor: 'transparent'
+                                }}
+                            >
+                                <Text
+                                    style={{
+                                        ...styles.text,
+                                        color: themeColor('warning'),
+                                        flex: 1
+                                    }}
+                                    numberOfLines={1}
+                                    ellipsizeMode="tail"
+                                >
+                                    {localeString(
+                                        'views.Cashu.MultimintPayment.noMintsSelected'
+                                    )}
+                                </Text>
+                                <CaretRight
+                                    stroke={themeColor('text')}
+                                    fill={themeColor('text')}
+                                    width={20}
+                                    height={20}
+                                />
+                            </Row>
+                        </TouchableOpacity>
+                    </View>
+                );
+            }
+
+            if (selectedMints.length === 1) {
+                return (
+                    <View style={{ flex: 1, flexDirection: 'row' }}>
+                        <TouchableOpacity
+                            onPress={() => navigation.navigate('Mints')}
+                            style={{
+                                opacity: disabled ? 0.25 : 1,
+                                backgroundColor: themeColor('secondary'),
+                                ...styles.field
+                            }}
+                        >
+                            {getRow(selectedMints[0], 'single')}
+                            <View style={styles.caretContainer}>
+                                <CaretRight
+                                    stroke={themeColor('text')}
+                                    fill={themeColor('text')}
+                                    width={20}
+                                    height={20}
+                                />
+                            </View>
+                        </TouchableOpacity>
+                    </View>
+                );
+            }
+
+            const shown = selectedMints.slice(0, 2);
+            const more = selectedMints.length - shown.length;
+            const totalRows = shown.length + (more > 0 ? 1 : 0);
+
+            return (
+                <View style={{ flex: 1, flexDirection: 'row' }}>
+                    <TouchableOpacity
+                        onPress={() => navigation.navigate('Mints')}
+                        style={{
+                            opacity: disabled ? 0.25 : 1,
+                            backgroundColor: themeColor('secondary'),
+                            ...styles.field,
+                            height: 42 * totalRows,
+                            marginBottom: 12
+                        }}
+                    >
+                        <View style={{ flex: 1 }}>
+                            {shown.map((mintUrl) => getRow(mintUrl))}
+                            {more > 0 && (
+                                <Row
+                                    style={{
+                                        height: 42,
+                                        alignItems: 'center',
+                                        paddingRight: 34,
+                                        backgroundColor: 'transparent'
+                                    }}
+                                >
+                                    <Text
+                                        style={{
+                                            color: themeColor('secondaryText'),
+                                            fontFamily: 'PPNeueMontreal-Book',
+                                            fontSize: 15,
+                                            flex: 1
+                                        }}
+                                    >{`+${more} more`}</Text>
+                                </Row>
+                            )}
+                            <View style={styles.caretContainer}>
+                                <CaretRight
+                                    stroke={themeColor('text')}
+                                    fill={themeColor('text')}
+                                    width={20}
+                                    height={20}
+                                />
+                            </View>
+                        </View>
+                    </TouchableOpacity>
+                </View>
+            );
+        }
+
         return (
             <View style={{ flex: 1, flexDirection: 'row' }}>
                 <TouchableOpacity
                     onPress={() => {
-                        navigation.navigate('Mints', { disableRandom });
+                        navigation.navigate('Mints', {
+                            disableRandom,
+                            forceSingleMint: multiMintEnabled && isReceiveView
+                        });
                     }}
                     style={{
                         opacity: disabled ? 0.25 : 1,
@@ -160,15 +344,22 @@ const styles = StyleSheet.create({
         fontSize: 18,
         fontFamily: 'PPNeueMontreal-Book'
     },
-    secondaryText: {
-        fontFamily: 'PPNeueMontreal-Book'
-    },
     field: {
-        justifyContent: 'center', // Centered vertically
+        justifyContent: 'center',
         width: '100%',
         height: 42,
         borderRadius: 6,
         paddingLeft: 10,
         overflow: 'hidden'
+    },
+    caretContainer: {
+        position: 'absolute',
+        right: 5,
+        top: 0,
+        bottom: 0,
+        justifyContent: 'center',
+        alignItems: 'center',
+        width: 24,
+        pointerEvents: 'none'
     }
 });
diff --git a/ios/CashuDevKit/CashuDevKitModule.m b/ios/CashuDevKit/CashuDevKitModule.m
index f5eaf9e1b..38e11a7e7 100644
--- a/ios/CashuDevKit/CashuDevKitModule.m
+++ b/ios/CashuDevKit/CashuDevKitModule.m
@@ -105,6 +105,17 @@ RCT_EXTERN_METHOD(melt:(NSString *)mintUrl
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(transferExactReceive:(NSString *)sourceMint
+                  targetMint:(NSString *)targetMint
+                  amount:(nonnull NSNumber *)amount
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(transferFullBalance:(NSString *)sourceMint
+                  targetMint:(NSString *)targetMint
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
 // Token Operations
 RCT_EXTERN_METHOD(prepareSend:(NSString *)mintUrl
                   amount:(nonnull NSNumber *)amount
diff --git a/ios/CashuDevKit/CashuDevKitModule.swift b/ios/CashuDevKit/CashuDevKitModule.swift
index 25ea0a904..ef14838e5 100644
--- a/ios/CashuDevKit/CashuDevKitModule.swift
+++ b/ios/CashuDevKit/CashuDevKitModule.swift
@@ -68,6 +68,32 @@ class CashuDevKitModule: RCTEventEmitter {
     return .p2pk(pubkey: pubkey, conditions: conditions)
   }
 
+    private func parseMeltOptions(from optionsJson: String?) -> MeltOptions? {
+        guard
+            let json = optionsJson,
+            let data = json.data(using: .utf8),
+            let parsed = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else {
+            return nil
+        }
+
+        if let mpp = parsed["mpp"] as? [String: Any],
+           let amountNumber = mpp["amount"] as? NSNumber,
+           amountNumber.uint64Value > 0 {
+            return .mpp(amount: Amount(value: amountNumber.uint64Value))
+        }
+
+        if let amountless = parsed["amountless"] as? [String: Any],
+           let amountMsatNumber = amountless["amount_msat"] as? NSNumber,
+           amountMsatNumber.uint64Value > 0 {
+            return .amountless(
+                amountMsat: Amount(value: amountMsatNumber.uint64Value)
+            )
+        }
+
+        return nil
+    }
+
     /// Returns the initialized wallet or rejects with NO_WALLET error
     private func getInitializedWallet(reject: @escaping RCTPromiseRejectBlock) -> MultiMintWallet? {
         guard isInitialized, let wallet = wallet else {
@@ -240,6 +266,16 @@ class CashuDevKitModule: RCTEventEmitter {
         return result
     }
 
+    private func encodeTransferResult(_ result: TransferResult) -> [String: Any] {
+        return [
+            "amount_sent": result.amountSent.value,
+            "amount_received": result.amountReceived.value,
+            "fees_paid": result.feesPaid.value,
+            "source_balance_after": result.sourceBalanceAfter.value,
+            "target_balance_after": result.targetBalanceAfter.value
+        ]
+    }
+
     private func encodeProof(_ proof: Proof) -> [String: Any] {
         let result: [String: Any] = [
             "amount": proof.amount.value,
@@ -761,7 +797,12 @@ class CashuDevKitModule: RCTEventEmitter {
         Task {
             do {
                 let url = MintUrl(url: mintUrl)
-                let quote = try await wallet.meltQuote(mintUrl: url, request: request, options: nil)
+                let options = parseMeltOptions(from: optionsJson)
+                let quote = try await wallet.meltQuote(
+                    mintUrl: url,
+                    request: request,
+                    options: options
+                )
                 resolve(encodeToJson(encodeMeltQuote(quote)))
             } catch let error as FfiError {
                 let (code, message) = mapFfiError(error)
@@ -812,6 +853,62 @@ class CashuDevKitModule: RCTEventEmitter {
         }
     }
 
+    @objc(transferExactReceive:targetMint:amount:resolver:rejecter:)
+    func transferExactReceive(_ sourceMint: String, targetMint: String, amount: NSNumber,
+                              resolve: @escaping RCTPromiseResolveBlock,
+                              reject: @escaping RCTPromiseRejectBlock) {
+        guard let wallet = getInitializedWallet(reject: reject) else { return }
+
+        Task {
+            do {
+                let sourceMintUrl = MintUrl(url: sourceMint)
+                let targetMintUrl = MintUrl(url: targetMint)
+                let transferMode = TransferMode.exactReceive(
+                    amount: Amount(value: amount.uint64Value)
+                )
+
+                let result = try await wallet.transfer(
+                    sourceMint: sourceMintUrl,
+                    targetMint: targetMintUrl,
+                    transferMode: transferMode
+                )
+
+                resolve(encodeToJson(encodeTransferResult(result)))
+            } catch let error as FfiError {
+                let (code, message) = mapFfiError(error)
+                reject(code, message, error)
+            } catch {
+                reject("TRANSFER_ERROR", error.localizedDescription, error)
+            }
+        }
+    }
+
+    @objc(transferFullBalance:targetMint:resolver:rejecter:)
+    func transferFullBalance(_ sourceMint: String, targetMint: String,
+                             resolve: @escaping RCTPromiseResolveBlock,
+                             reject: @escaping RCTPromiseRejectBlock) {
+        guard let wallet = getInitializedWallet(reject: reject) else { return }
+
+        Task {
+            do {
+                let sourceMintUrl = MintUrl(url: sourceMint)
+                let targetMintUrl = MintUrl(url: targetMint)
+                let result = try await wallet.transfer(
+                    sourceMint: sourceMintUrl,
+                    targetMint: targetMintUrl,
+                    transferMode: .fullBalance
+                )
+
+                resolve(encodeToJson(encodeTransferResult(result)))
+            } catch let error as FfiError {
+                let (code, message) = mapFfiError(error)
+                reject(code, message, error)
+            } catch {
+                reject("TRANSFER_ERROR", error.localizedDescription, error)
+            }
+        }
+    }
+
     // MARK: - Token Operations
 
     @objc(prepareSend:amount:optionsJson:resolver:rejecter:)
@@ -1201,7 +1298,12 @@ class CashuDevKitModule: RCTEventEmitter {
         Task {
             do {
                 let url = MintUrl(url: mintUrl)
-                let quote = try await wallet.meltQuote(mintUrl: url, request: request, options: nil)
+                let options = parseMeltOptions(from: optionsJson)
+                let quote = try await wallet.meltQuote(
+                    mintUrl: url,
+                    request: request,
+                    options: options
+                )
                 resolve(encodeToJson(encodeMeltQuote(quote)))
             } catch let error as FfiError {
                 let (code, message) = mapFfiError(error)
diff --git a/locales/en.json b/locales/en.json
index 8bdd6148b..9d9aba93b 100644
--- a/locales/en.json
+++ b/locales/en.json
@@ -2058,6 +2058,7 @@
     "views.Settings.NostrWalletConnect.nwcIncludeLud16InUrl": "Include Lightning Address",
     "views.Settings.NostrWalletConnect.nwcIncludeLud16InUrlDescription": "When enabled, your Lightning address (LUD-16) is added to new and regenerated NWC connection URLs. Some Nostr clients will set this as your Lightning address in your profile. Turn off if you prefer not to share it with the connecting app.",
     "views.Settings.NostrWalletConnect.chooseRelay": "Choose the Nostr relay for this connection",
+    "views.Settings.Ecash.enableMultiMintSends": "Enable Cashu Multi-mint sends",
     "views.LspExplanation.text1": "Zeus is a self-custodial lightning wallet. In order to send or receive a lightning payment, you must open a lightning payment channel, which has a setup fee.",
     "views.LspExplanation.text2": "Once the channel is set up, you'll only have to pay normal network fees until your channel exhausts its capacity.",
     "views.LspExplanation.buttonText": "Learn more about liquidity",
@@ -2232,6 +2233,7 @@
     "views.Cashu.AddMint.tapToExpand": "Tap to expand",
     "views.Cashu.AddMint.tapToCollapse": "Tap to collapse",
     "views.Mints.noMints": "No mints added yet",
+    "views.Cashu.Mints.nut15Required": "NUT-15 required",
     "views.Cashu.Mint.supportedNuts": "Supported Nuts",
     "views.Cashu.Mint.removeMint": "Remove mint",
     "views.Cashu.Mint.selectedMint": "This is your selected mint",
@@ -2260,6 +2262,8 @@
     "views.Cashu.Mint.publishedAs": "Published as:",
     "views.Cashu.CashuPaymentRequest.sendingFrom": "Sending from",
     "views.Cashu.CashuPaymentRequest.noBalance": "No ecash balance available. Receive a payment first.",
+    "views.Cashu.CashuPaymentRequest.multiMint": "Multi-mint",
+    "views.Cashu.MultimintPayment.noMintsSelected": "No mints selected. Please select at least one mint to proceed.",
     "views.Cashu.CashuPayment.inTransitPayment": "In Transit Cashu Payment",
     "views.Cashu.CashuPayment.failedPayment": "Failed Cashu Payment",
     "views.Cashu.CashuToken.proofCount": "Number of proofs",
diff --git a/stores/CashuStore.ts b/stores/CashuStore.ts
index 77c204f7f..7f2cde6cd 100644
--- a/stores/CashuStore.ts
+++ b/stores/CashuStore.ts
@@ -10,6 +10,7 @@ import CashuDevKit, {
     CDKMintQuote,
     CDKMeltQuote,
     CDKMelted,
+    CDKTransferResult,
     CDKToken,
     CDKSendKind,
     CDKSpendingConditions,
@@ -53,7 +54,10 @@ import ModalStore from './ModalStore';
 
 import Base64Utils from '../utils/Base64Utils';
 import { BIP39_WORD_LIST } from '../utils/Bip39Utils';
-import CashuUtils from '../utils/CashuUtils';
+import CashuUtils, {
+    MintPaymentStatus,
+    MintProgressInfo
+} from '../utils/CashuUtils';
 import { errorToUserFriendly } from '../utils/ErrorUtils';
 import { localeString } from '../utils/LocaleUtils';
 import MigrationsUtils from '../utils/MigrationUtils';
@@ -160,6 +164,7 @@ export default class CashuStore {
     @observable public mintUrls: Array<string>;
     @observable public selectedMintUrl: string;
     @observable public randomizeMintSelection: boolean = false;
+    @observable public selectedMintUrls: string[] = [];
     @observable public cashuWallets: { [key: string]: Wallet } = {};
     @observable public totalBalanceSats: number;
     // Per-mint data fetched from CDK
@@ -213,6 +218,7 @@ export default class CashuStore {
     @observable public paymentStartTime?: number;
     @observable public paymentDuration?: number;
     @observable public paymentFee?: number;
+    @observable public lastMultiMintUsedMints: string[] = [];
 
     @observable public mintRecommendations?: MintRecommendation[];
     @observable public trustedMintRecommendations?: MintRecommendation[];
@@ -296,6 +302,7 @@ export default class CashuStore {
         this.paymentErrorMsg = '';
         this.paymentStartTime = undefined;
         this.noteKey = undefined;
+        this.lastMultiMintUsedMints = [];
     };
 
     /**
@@ -878,14 +885,19 @@ export default class CashuStore {
      */
     public createMeltQuoteCDK = async (
         mintUrl: string,
-        bolt11Invoice: string
+        bolt11Invoice: string,
+        options?: any
     ): Promise<CDKMeltQuote> => {
         if (!this.cdkInitialized) {
             throw new Error('CDK not initialized');
         }
 
         await this.ensureMintAdded(mintUrl);
-        return await CashuDevKit.createMeltQuote(mintUrl, bolt11Invoice);
+        return await CashuDevKit.createMeltQuote(
+            mintUrl,
+            bolt11Invoice,
+            options
+        );
     };
 
     /**
@@ -909,6 +921,293 @@ export default class CashuStore {
         return result;
     };
 
+    /**
+     * CDK: Top up a target mint by transferring balance from other mints.
+     * Returns total amount received by the target mint.
+     */
+    private transferToMintCDK = async (
+        targetMintUrl: string,
+        amountNeeded: number
+    ): Promise<number> => {
+        if (amountNeeded <= 0) {
+            return 0;
+        }
+
+        const normalizedTargetMint = this.normalizeMintUrl(targetMintUrl);
+        const balances = await CashuDevKit.getBalances();
+
+        const useSelectedSources =
+            !!this.settingsStore.settings?.ecash?.enableMultiMint &&
+            Array.isArray(this.selectedMintUrls) &&
+            this.selectedMintUrls.length > 0;
+
+        const allowedSources = useSelectedSources
+            ? new Set(
+                  this.selectedMintUrls.map((mint) =>
+                      this.normalizeMintUrl(mint)
+                  )
+              )
+            : null;
+
+        const sourceMints = Object.entries(balances)
+            .filter(([mintUrl, balance]) => {
+                const normalizedSourceMint = this.normalizeMintUrl(mintUrl);
+                return (
+                    normalizedSourceMint !== normalizedTargetMint &&
+                    balance > 0 &&
+                    (!allowedSources ||
+                        allowedSources.has(normalizedSourceMint))
+                );
+            })
+            .sort((a, b) => b[1] - a[1]);
+
+        let totalReceived = 0;
+
+        for (const [sourceMintUrl] of sourceMints) {
+            const remainingNeeded = amountNeeded - totalReceived;
+            if (remainingNeeded <= 0) {
+                break;
+            }
+
+            let transferResult: CDKTransferResult;
+            try {
+                transferResult = await CashuDevKit.transferExactReceive(
+                    sourceMintUrl,
+                    normalizedTargetMint,
+                    remainingNeeded
+                );
+            } catch (e) {
+                try {
+                    transferResult = await CashuDevKit.transferFullBalance(
+                        sourceMintUrl,
+                        normalizedTargetMint
+                    );
+                } catch (fallbackError) {
+                    continue;
+                }
+            }
+
+            totalReceived += transferResult.amount_received || 0;
+        }
+
+        await this.syncCDKBalances();
+        return totalReceived;
+    };
+
+    private mintSupportsMpp = (mintUrl: string): boolean => {
+        const normalizedMintUrl = this.normalizeMintUrl(mintUrl);
+        const mintInfo =
+            this.mintInfos[normalizedMintUrl] || this.mintInfos[mintUrl];
+        const nuts: any = mintInfo?.nuts;
+
+        return !!(nuts && (nuts[15] || nuts['15']));
+    };
+
+    private payLnInvoiceFromEcashMultiMint = async ({
+        paymentAmt,
+        isDonationPayment
+    }: {
+        paymentAmt: number;
+        isDonationPayment: boolean;
+    }): Promise<CashuPayment | undefined> => {
+        const paymentRequest = this.paymentRequest;
+        if (!paymentRequest) {
+            runInAction(() => {
+                this.paymentError = true;
+                this.paymentErrorMsg = 'No payment request available';
+                this.loading = false;
+            });
+            return;
+        }
+
+        const selectedMints =
+            this.selectedMintUrls.length > 0
+                ? this.selectedMintUrls
+                : this.selectedMintUrl
+                ? [this.selectedMintUrl]
+                : [];
+
+        const uniqueSelectedMints = Array.from(
+            new Set(selectedMints.map((mint) => this.normalizeMintUrl(mint)))
+        );
+
+        const supportedMints = uniqueSelectedMints.filter((mintUrl) =>
+            this.mintSupportsMpp(mintUrl)
+        );
+
+        if (supportedMints.length === 0) {
+            runInAction(() => {
+                this.paymentError = true;
+                this.paymentErrorMsg = localeString(
+                    'stores.CashuStore.notEnoughFunds'
+                );
+                this.loading = false;
+            });
+            return;
+        }
+
+        const balances = await CashuDevKit.getBalances();
+        const normalizedBalances = Object.entries(balances).reduce(
+            (acc, [mintUrl, balance]) => {
+                acc[this.normalizeMintUrl(mintUrl)] = balance;
+                return acc;
+            },
+            {} as Record<string, number>
+        );
+
+        const mintsBySmallestBalance = supportedMints
+            .map((mintUrl) => ({
+                mintUrl,
+                balance: normalizedBalances[mintUrl] || 0
+            }))
+            .filter(({ balance }) => balance > 0)
+            .sort((a, b) => a.balance - b.balance);
+
+        if (mintsBySmallestBalance.length === 0) {
+            runInAction(() => {
+                this.paymentError = true;
+                this.paymentErrorMsg = localeString(
+                    'stores.CashuStore.notEnoughFunds'
+                );
+                this.loading = false;
+            });
+            return;
+        }
+
+        let remainingAmount = paymentAmt;
+        let totalFeePaid = 0;
+        const segmentPayments: CashuPayment[] = [];
+
+        for (const { mintUrl } of mintsBySmallestBalance) {
+            if (remainingAmount <= 0) {
+                break;
+            }
+
+            let mintBalance = normalizedBalances[mintUrl] || 0;
+            if (mintBalance <= 0) {
+                continue;
+            }
+
+            const initialAllocation = Math.min(remainingAmount, mintBalance);
+            if (initialAllocation <= 0) {
+                continue;
+            }
+
+            await this.ensureMintAdded(mintUrl);
+
+            let quote = await this.createMeltQuoteCDK(mintUrl, paymentRequest, {
+                mpp: { amount: initialAllocation }
+            });
+
+            let requiredFromMint = quote.amount + quote.fee_reserve;
+
+            if (requiredFromMint > mintBalance) {
+                const affordableAllocation = Math.max(
+                    0,
+                    Math.min(remainingAmount, mintBalance - quote.fee_reserve)
+                );
+
+                if (affordableAllocation <= 0) {
+                    continue;
+                }
+
+                quote = await this.createMeltQuoteCDK(mintUrl, paymentRequest, {
+                    mpp: { amount: affordableAllocation }
+                });
+                requiredFromMint = quote.amount + quote.fee_reserve;
+
+                if (requiredFromMint > mintBalance) {
+                    continue;
+                }
+            }
+
+            const meltResult = await CashuDevKit.melt(mintUrl, quote.id);
+            const paidAmount = meltResult.amount || quote.amount;
+            const meltState = (
+                meltResult.state ||
+                quote.state ||
+                ''
+            ).toString();
+            const normalizedMeltState =
+                meltState.length > 0 ? meltState.toUpperCase() : 'PAID';
+
+            totalFeePaid += meltResult.fee_paid || 0;
+            remainingAmount = Math.max(0, remainingAmount - paidAmount);
+            mintBalance = Math.max(0, mintBalance - requiredFromMint);
+            normalizedBalances[mintUrl] = mintBalance;
+
+            const payment = new CashuPayment({
+                ...this.payReq,
+                bolt11: this.paymentRequest,
+                meltResponse: {
+                    quote: {
+                        quote: quote.id,
+                        amount: quote.amount,
+                        fee_reserve: quote.fee_reserve,
+                        state: normalizedMeltState,
+                        expiry: quote.expiry,
+                        payment_preimage: meltResult.preimage || null
+                    },
+                    change: meltResult.change,
+                    state: normalizedMeltState,
+                    amount: meltResult.amount,
+                    fee_paid: meltResult.fee_paid,
+                    preimage: meltResult.preimage
+                },
+                amount: meltResult.amount,
+                fee: meltResult.fee_paid,
+                payment_preimage: meltResult.preimage || '',
+                mintUrl
+            });
+
+            segmentPayments.push(payment);
+        }
+
+        if (remainingAmount > 0) {
+            runInAction(() => {
+                this.paymentError = true;
+                this.paymentErrorMsg = localeString(
+                    'stores.CashuStore.notEnoughFunds'
+                );
+                this.loading = false;
+            });
+            return;
+        }
+
+        this.payments?.push(...segmentPayments);
+        await Storage.setItem(
+            `${this.getLndDir()}-cashu-payments`,
+            this.payments
+        );
+
+        await this.syncCDKBalances(true);
+
+        runInAction(() => {
+            this.lastMultiMintUsedMints = segmentPayments.map(
+                (payment) => payment.mintUrl
+            );
+
+            if (!isDonationPayment) {
+                const preimage = segmentPayments
+                    .map((payment) => payment?.payment_preimage)
+                    .find((value) => !!value);
+
+                this.paymentPreimage = preimage || '';
+                this.paymentSuccess = true;
+                this.paymentFee = totalFeePaid;
+                this.noteKey = segmentPayments[0]?.getNoteKey;
+                this.loading = false;
+            }
+
+            if (this.paymentStartTime) {
+                this.paymentDuration =
+                    (Date.now() - this.paymentStartTime) / 1000;
+            }
+        });
+
+        return segmentPayments[0];
+    };
+
     /**
      * Enrich tokens with value if missing (migration for old tokens)
      */
@@ -1210,6 +1509,7 @@ export default class CashuStore {
         this.totalBalanceSats = 0;
         this.mintUrls = [];
         this.selectedMintUrl = '';
+        this.selectedMintUrls = [];
         this.invoices = undefined;
         this.payments = undefined;
         this.receivedTokens = undefined;
@@ -1881,6 +2181,28 @@ export default class CashuStore {
 
     @action
     public setSelectedMint = async (mintUrl: string) => {
+        this.clearInvoice();
+        await Promise.all([
+            Storage.setItem(
+                `${this.getLndDir()}-cashu-selectedMintUrl`,
+                mintUrl
+            ),
+            Storage.setItem(
+                `${this.getLndDir()}-cashu-selectedMintUrls`,
+                JSON.stringify([mintUrl])
+            )
+        ]);
+
+        runInAction(() => {
+            this.selectedMintUrl = mintUrl;
+            this.selectedMintUrls = [mintUrl];
+        });
+
+        return mintUrl;
+    };
+
+    @action
+    public setReceiveMint = async (mintUrl: string) => {
         this.clearInvoice();
         await Storage.setItem(
             `${this.getNodeDir()}-cashu-selectedMintUrl`,
@@ -1917,6 +2239,52 @@ export default class CashuStore {
         return mintsToUse[index];
     };
 
+    @action
+    public setSelectedMintUrls = async (mintUrls: string[]) => {
+        const uniqueMintUrls = Array.from(new Set(mintUrls));
+
+        await Storage.setItem(
+            `${this.getLndDir()}-cashu-selectedMintUrls`,
+            JSON.stringify(uniqueMintUrls)
+        );
+
+        runInAction(() => {
+            this.selectedMintUrls = uniqueMintUrls;
+
+            if (!uniqueMintUrls.includes(this.selectedMintUrl)) {
+                this.selectedMintUrl =
+                    uniqueMintUrls[0] || this.selectedMintUrl;
+            }
+        });
+
+        if (this.selectedMintUrl) {
+            await Storage.setItem(
+                `${this.getLndDir()}-cashu-selectedMintUrl`,
+                this.selectedMintUrl
+            );
+        }
+
+        return uniqueMintUrls;
+    };
+
+    @action
+    public toggleMintSelection = async (mintUrl: string): Promise<void> => {
+        const currentSelection = Array.isArray(this.selectedMintUrls)
+            ? [...this.selectedMintUrls]
+            : [];
+
+        const isSelected = currentSelection.includes(mintUrl);
+        if (isSelected && currentSelection.length === 1) {
+            return;
+        }
+
+        const nextSelected = isSelected
+            ? currentSelection.filter((url) => url !== mintUrl)
+            : [...currentSelection, mintUrl];
+
+        await this.setSelectedMintUrls(nextSelected);
+    };
+
     @action
     public addMint = async (
         mintUrl: string,
@@ -2014,6 +2382,21 @@ export default class CashuStore {
         }
     };
 
+    @action
+    public getMultimintInfo = (): MintProgressInfo[] => {
+        const availableMints = this.mintUrls.map((mintUrl) => {
+            const mintName = this.mintInfos[mintUrl]?.name || mintUrl;
+            return {
+                mintUrl,
+                mintName,
+                balance: this.mintBalances[mintUrl] || 0,
+                status: MintPaymentStatus.IDLE,
+                error: undefined
+            };
+        });
+        return availableMints;
+    };
+
     @action
     public removeMint = async (mintUrl: string) => {
         this.loading = true;
@@ -2054,6 +2437,22 @@ export default class CashuStore {
             }
         }
 
+        const filteredSelectedMintUrls = (this.selectedMintUrls || []).filter(
+            (selectedMint) =>
+                this.normalizeMintUrl(selectedMint) !==
+                this.normalizeMintUrl(mintUrl)
+        );
+        this.selectedMintUrls =
+            filteredSelectedMintUrls.length > 0
+                ? filteredSelectedMintUrls
+                : this.selectedMintUrl
+                ? [this.selectedMintUrl]
+                : [];
+        await Storage.setItem(
+            `${this.getLndDir()}-cashu-selectedMintUrls`,
+            JSON.stringify(this.selectedMintUrls)
+        );
+
         // Clean up any legacy local storage for this mint
         const walletId = `${this.getNodeDir()}==${mintUrl}`;
         await Storage.removeItem(`${walletId}-counter`);
@@ -2431,6 +2830,7 @@ export default class CashuStore {
         const [
             storedMintUrls, // Only needed for migration to CDK
             storedselectedMintUrl,
+            storedselectedMintUrls,
             storedInvoices,
             storedPayments,
             storedReceivedTokens,
@@ -2442,6 +2842,7 @@ export default class CashuStore {
         ] = await Promise.all([
             Storage.getItem(`${lndDir}-cashu-mintUrls`),
             Storage.getItem(`${lndDir}-cashu-selectedMintUrl`),
+            Storage.getItem(`${lndDir}-cashu-selectedMintUrls`),
             Storage.getItem(`${lndDir}-cashu-invoices`),
             Storage.getItem(`${lndDir}-cashu-payments`),
             Storage.getItem(`${lndDir}-cashu-received-tokens`),
@@ -2455,6 +2856,11 @@ export default class CashuStore {
         // Parse app-specific stored data
         this.selectedMintUrl = storedselectedMintUrl || '';
         this.randomizeMintSelection = storedRandomizeMintSelection === 'true';
+        this.selectedMintUrls = storedselectedMintUrls
+            ? JSON.parse(storedselectedMintUrls)
+            : this.selectedMintUrl
+            ? [this.selectedMintUrl]
+            : [];
         this.invoices = storedInvoices
             ? JSON.parse(storedInvoices).map(
                   (invoice: any) => new CashuInvoice(invoice)
@@ -2847,6 +3253,24 @@ export default class CashuStore {
             );
         }
 
+        const selectedMintUrls = (this.selectedMintUrls || []).filter((mint) =>
+            this.mintUrls.includes(mint)
+        );
+
+        this.selectedMintUrls =
+            selectedMintUrls.length > 0
+                ? selectedMintUrls
+                : this.selectedMintUrl
+                ? [this.selectedMintUrl]
+                : this.mintUrls[0]
+                ? [this.mintUrls[0]]
+                : [];
+
+        await Storage.setItem(
+            `${lndDir}-cashu-selectedMintUrls`,
+            JSON.stringify(this.selectedMintUrls)
+        );
+
         runInAction(() => {
             this.loadingMsg = undefined;
             this.initializing = false;
@@ -3399,28 +3823,44 @@ export default class CashuStore {
 
         const mintUrl = this.selectedMintUrl;
 
-        if (!this.meltQuote) {
-            if (!isDonationPayment) {
-                runInAction(() => {
-                    this.paymentError = true;
-                    this.paymentErrorMsg = 'No melt quote available';
-                    this.loading = false;
-                });
-            }
-            return;
-        }
-
         try {
             const paymentAmt = this.payReq?.getRequestAmount
                 ? this.payReq?.getRequestAmount
                 : Number(amount);
 
+            const shouldUseMultiMint =
+                !!this.settingsStore.settings?.ecash?.enableMultiMint &&
+                Array.isArray(this.selectedMintUrls) &&
+                this.selectedMintUrls.length > 1;
+
+            if (shouldUseMultiMint) {
+                return await this.payLnInvoiceFromEcashMultiMint({
+                    paymentAmt,
+                    isDonationPayment
+                });
+            }
+
+            if (!this.meltQuote) {
+                runInAction(() => {
+                    this.paymentError = true;
+                    this.paymentErrorMsg = 'No melt quote available';
+                    this.loading = false;
+                });
+                return;
+            }
+
             // Check balance via CDK
-            const balance = await CashuDevKit.getMintBalance(mintUrl);
             const amountToPay = this.feeEstimate
                 ? this.feeEstimate + paymentAmt
                 : paymentAmt;
 
+            let balance = await CashuDevKit.getMintBalance(mintUrl);
+
+            if (balance < amountToPay) {
+                await this.transferToMintCDK(mintUrl, amountToPay - balance);
+                balance = await CashuDevKit.getMintBalance(mintUrl);
+            }
+
             if (balance < amountToPay) {
                 if (!isDonationPayment) {
                     runInAction(() => {
@@ -3472,7 +3912,9 @@ export default class CashuStore {
                 if (!isDonationPayment) {
                     this.paymentPreimage = paymentPreimage;
                     this.paymentSuccess = true;
+                    this.paymentFee = realFee;
                     this.noteKey = payment.getNoteKey;
+                    this.lastMultiMintUsedMints = [mintUrl];
                     this.loading = false;
 
                     if (this.paymentStartTime) {
@@ -4343,6 +4785,7 @@ export default class CashuStore {
 
             // Clean up app-specific storage
             await Storage.removeItem(`${lndDir}-cashu-selectedMintUrl`);
+            await Storage.removeItem(`${lndDir}-cashu-selectedMintUrls`);
             await Storage.removeItem(`${lndDir}-cashu-invoices`);
             await Storage.removeItem(`${lndDir}-cashu-payments`);
             await Storage.removeItem(`${lndDir}-cashu-received-tokens`);
diff --git a/stores/SettingsStore.ts b/stores/SettingsStore.ts
index c2cff5435..51a0b8812 100644
--- a/stores/SettingsStore.ts
+++ b/stores/SettingsStore.ts
@@ -171,6 +171,7 @@ interface Bolt12AddressSettings {
 
 interface EcashSettings {
     enableCashu: boolean;
+    enableMultiMint: boolean;
     automaticallySweep: boolean;
     sweepThresholdSats?: number;
     initialMintUrls?: string[];
@@ -1601,6 +1602,7 @@ export default class SettingsStore {
         },
         ecash: {
             enableCashu: false,
+            enableMultiMint: false,
             automaticallySweep: false,
             sweepThresholdSats: 10000
         },
diff --git a/utils/CashuUtils.ts b/utils/CashuUtils.ts
index 5009b4299..2d5d5d29a 100644
--- a/utils/CashuUtils.ts
+++ b/utils/CashuUtils.ts
@@ -191,3 +191,26 @@ class CashuUtils {
 
 const cashuUtils = new CashuUtils();
 export default cashuUtils;
+
+export enum MintPaymentStatus {
+    IDLE = 'idle',
+    REQUESTING = 'requesting',
+    PAYING = 'paying',
+    SUCCESS = 'success',
+    FAILED = 'failed'
+}
+
+export enum MultinutPaymentStep {
+    IDLE = 'idle',
+    PROCESSING = 'processing',
+    COMPLETE = 'complete',
+    FAILED = 'failed'
+}
+
+export interface MintProgressInfo {
+    mintUrl: string;
+    mintName: string;
+    balance: number;
+    status: MintPaymentStatus;
+    error?: string;
+}
diff --git a/views/Cashu/CashuPaymentRequest.tsx b/views/Cashu/CashuPaymentRequest.tsx
index 8cf3a3c11..17baa388f 100644
--- a/views/Cashu/CashuPaymentRequest.tsx
+++ b/views/Cashu/CashuPaymentRequest.tsx
@@ -23,6 +23,7 @@ import Header from '../../components/Header';
 import KeyValue from '../../components/KeyValue';
 import LoadingIndicator from '../../components/LoadingIndicator';
 import Screen from '../../components/Screen';
+import Switch from '../../components/Switch';
 import { WarningMessage } from '../../components/SuccessErrorMessage';
 
 import BalanceStore from '../../stores/BalanceStore';
@@ -77,6 +78,7 @@ interface CashuPaymentRequestState {
     donationAmount: any;
     selectedIndex: number | null;
     swipeButtonKey: number;
+    multiMintLoading: boolean;
 }
 
 @inject(
@@ -105,7 +107,8 @@ export default class CashuPaymentRequest extends React.Component<
         donationPercentage: 0,
         donationAmount: 0,
         selectedIndex: null,
-        swipeButtonKey: 0
+        swipeButtonKey: 0,
+        multiMintLoading: false
     };
 
     async componentDidMount() {
@@ -148,7 +151,8 @@ export default class CashuPaymentRequest extends React.Component<
         this.focusListener = this.props.navigation.addListener('focus', () => {
             getPayReq(paymentRequest!!);
             this.setState({
-                swipeButtonKey: this.state.swipeButtonKey + 1
+                swipeButtonKey: this.state.swipeButtonKey + 1,
+                multiMintLoading: false
             });
         });
     }
@@ -186,9 +190,16 @@ export default class CashuPaymentRequest extends React.Component<
     };
 
     triggerPayment = () => {
-        const { LnurlPayStore } = this.props;
+        const { LnurlPayStore, navigation, SettingsStore } = this.props;
         const { satAmount } = this.state;
 
+        if (SettingsStore.settings?.ecash?.enableMultiMint) {
+            navigation.navigate('MultimintPayment', {
+                paymentAmount: satAmount ? satAmount.toString() : undefined
+            });
+            return;
+        }
+
         // Zaplocker
         const { isZaplocker } = LnurlPayStore;
 
@@ -210,7 +221,8 @@ export default class CashuPaymentRequest extends React.Component<
             slideToPayThreshold,
             donationsToggle,
             donationAmount,
-            donationPercentage
+            donationPercentage,
+            multiMintLoading
         } = this.state;
         const {
             payReq,
@@ -220,7 +232,8 @@ export default class CashuPaymentRequest extends React.Component<
             loadingFeeEstimate,
             feeEstimate,
             clearPayReq,
-            totalBalanceSats
+            totalBalanceSats,
+            selectedMintUrls
         } = CashuStore;
 
         // Zaplocker
@@ -251,6 +264,7 @@ export default class CashuPaymentRequest extends React.Component<
         const isNoAmountInvoice: boolean = !requestAmount;
 
         const noBalance = totalBalanceSats === 0;
+        const multiMintEnabled = !!settings?.ecash?.enableMultiMint;
 
         const enableDonations =
             Platform.OS !== 'ios' && settings?.payments?.enableDonations;
@@ -846,32 +860,151 @@ export default class CashuPaymentRequest extends React.Component<
                     !loadingFeeEstimate &&
                     BackendUtils.supportsLightningSends() && (
                         <View style={{ bottom: 10, top: 6 }}>
-                            <View
-                                style={{
-                                    alignSelf: 'center',
-                                    width: '85%',
-                                    marginBottom: 30
-                                }}
-                            >
-                                <Text
-                                    style={{
-                                        ...styles.label,
-                                        color: themeColor('secondaryText')
-                                    }}
-                                >
-                                    {localeString(
-                                        'views.Cashu.CashuPaymentRequest.sendingFrom'
-                                    )}
-                                </Text>
-                                <View style={{ marginTop: 10 }}>
-                                    <EcashMintPicker
-                                        disableRandom
-                                        navigation={navigation}
-                                    />
-                                </View>
-                            </View>
+                            {(() => {
+                                let totalRows = 1;
+                                if (
+                                    multiMintEnabled &&
+                                    selectedMintUrls.length > 0
+                                ) {
+                                    if (selectedMintUrls.length === 1) {
+                                        totalRows = 1;
+                                    } else {
+                                        const shown = Math.min(
+                                            selectedMintUrls.length,
+                                            2
+                                        );
+                                        const more =
+                                            selectedMintUrls.length - shown;
+                                        totalRows = shown + (more > 0 ? 1 : 0);
+                                    }
+                                }
+
+                                const marginBottom =
+                                    totalRows === 3
+                                        ? 90
+                                        : totalRows === 2
+                                        ? 50
+                                        : 30;
+
+                                return (
+                                    <View
+                                        style={{
+                                            alignSelf: 'center',
+                                            width: '85%',
+                                            marginBottom
+                                        }}
+                                    >
+                                        <Row
+                                            justify="space-between"
+                                            style={{ alignItems: 'center' }}
+                                        >
+                                            <Text
+                                                style={{
+                                                    ...styles.label,
+                                                    color: themeColor(
+                                                        'secondaryText'
+                                                    )
+                                                }}
+                                            >
+                                                {localeString(
+                                                    'views.Cashu.CashuPaymentRequest.sendingFrom'
+                                                )}
+                                            </Text>
+                                            <Row
+                                                style={{ alignItems: 'center' }}
+                                            >
+                                                <Text
+                                                    style={{
+                                                        color: themeColor(
+                                                            'secondaryText'
+                                                        ),
+                                                        fontSize: 15,
+                                                        fontFamily:
+                                                            'PPNeueMontreal-Book',
+                                                        marginRight: 8
+                                                    }}
+                                                >
+                                                    {localeString(
+                                                        'views.Cashu.CashuPaymentRequest.multiMint'
+                                                    )}
+                                                </Text>
+                                                <View
+                                                    style={{
+                                                        width: 51,
+                                                        height: 31,
+                                                        justifyContent:
+                                                            'center',
+                                                        alignItems: 'center'
+                                                    }}
+                                                >
+                                                    {multiMintLoading ? (
+                                                        <LoadingIndicator
+                                                            size={30}
+                                                        />
+                                                    ) : (
+                                                        <Switch
+                                                            value={
+                                                                multiMintEnabled
+                                                            }
+                                                            onValueChange={async () => {
+                                                                this.setState({
+                                                                    multiMintLoading:
+                                                                        true
+                                                                });
+                                                                try {
+                                                                    await SettingsStore.updateSettings(
+                                                                        {
+                                                                            ecash: {
+                                                                                ...settings.ecash,
+                                                                                enableMultiMint:
+                                                                                    !multiMintEnabled
+                                                                            }
+                                                                        }
+                                                                    );
+
+                                                                    if (
+                                                                        CashuStore.paymentRequest
+                                                                    ) {
+                                                                        await CashuStore.getPayReq(
+                                                                            CashuStore.paymentRequest
+                                                                        );
+                                                                    }
+                                                                } finally {
+                                                                    this.setState(
+                                                                        {
+                                                                            multiMintLoading:
+                                                                                false
+                                                                        }
+                                                                    );
+                                                                }
+                                                            }}
+                                                            disabled={
+                                                                SettingsStore.settingsUpdateInProgress ||
+                                                                multiMintLoading
+                                                            }
+                                                        />
+                                                    )}
+                                                </View>
+                                            </Row>
+                                        </Row>
+                                        <View
+                                            style={{
+                                                marginTop: 10,
+                                                marginBottom: 20
+                                            }}
+                                        >
+                                            <EcashMintPicker
+                                                disableRandom
+                                                navigation={navigation}
+                                            />
+                                        </View>
+                                    </View>
+                                );
+                            })()}
                             {requestAmount &&
-                            requestAmount >= slideToPayThreshold ? (
+                            requestAmount >= slideToPayThreshold &&
+                            !multiMintLoading &&
+                            !SettingsStore.settingsUpdateInProgress ? (
                                 <SwipeButton
                                     key={this.state.swipeButtonKey}
                                     onSwipeSuccess={this.triggerPayment}
@@ -887,6 +1020,16 @@ export default class CashuPaymentRequest extends React.Component<
                                         backgroundColor: themeColor('text')
                                     }}
                                 />
+                            ) : requestAmount &&
+                              requestAmount >= slideToPayThreshold ? (
+                                <View style={styles.button}>
+                                    <Button
+                                        title={localeString(
+                                            'views.PaymentRequest.slideToPay'
+                                        )}
+                                        disabled
+                                    />
+                                </View>
                             ) : (
                                 <View style={styles.button}>
                                     <Button
@@ -898,6 +1041,10 @@ export default class CashuPaymentRequest extends React.Component<
                                             size: 25
                                         }}
                                         onPress={this.triggerPayment}
+                                        disabled={
+                                            multiMintLoading ||
+                                            SettingsStore.settingsUpdateInProgress
+                                        }
                                     />
                                 </View>
                             )}
diff --git a/views/Cashu/CashuSendingLightning.tsx b/views/Cashu/CashuSendingLightning.tsx
index bbc568f50..ef9af211d 100644
--- a/views/Cashu/CashuSendingLightning.tsx
+++ b/views/Cashu/CashuSendingLightning.tsx
@@ -185,14 +185,25 @@ export default class CashuSendingLightning extends React.Component<
                 isDonationPayment
             });
 
-            if (!donationPayment || !donationPayment.payment_preimage) {
+            const payment = Array.isArray(donationPayment)
+                ? donationPayment[0]
+                : donationPayment;
+
+            const donationState = (
+                payment?.meltResponse?.quote?.state ||
+                payment?.meltResponse?.state
+            )
+                ?.toString()
+                ?.toUpperCase();
+
+            if (!payment || donationState !== 'PAID') {
                 console.log('Donation payment failed.');
                 this.setState({ donationHandled: false });
                 return;
             }
 
-            const amountDonated = donationPayment?.amount;
-            const paymentPreimage = donationPayment?.payment_preimage;
+            const amountDonated = payment?.amount;
+            const paymentPreimage = payment?.payment_preimage;
 
             this.setState({
                 donationHandled: true,
diff --git a/views/Cashu/LegacySeedRecovery.tsx b/views/Cashu/LegacySeedRecovery.tsx
index 59f78adfc..5eb28b5d8 100644
--- a/views/Cashu/LegacySeedRecovery.tsx
+++ b/views/Cashu/LegacySeedRecovery.tsx
@@ -184,6 +184,7 @@ export default class LegacySeedRecovery extends React.Component<
                             disableRandom
                             navigation={navigation}
                             hideAmount
+                            isReceiveView
                             disabled={checking}
                         />
                     </View>
diff --git a/views/Cashu/LightningAddress/LightningAddressSettings.tsx b/views/Cashu/LightningAddress/LightningAddressSettings.tsx
index 9cf21a012..6d2109fc3 100644
--- a/views/Cashu/LightningAddress/LightningAddressSettings.tsx
+++ b/views/Cashu/LightningAddress/LightningAddressSettings.tsx
@@ -352,7 +352,11 @@ export default class CashuLightningAddressSettings extends React.Component<
                                 <Button
                                     title={localeString('cashu.tapToConfigure')}
                                     warning
-                                    onPress={() => navigation.navigate('Mints')}
+                                    onPress={() =>
+                                        navigation.navigate('Mints', {
+                                            forceSingleMint: true
+                                        })
+                                    }
                                 />
                             </View>
                         ) : (
diff --git a/views/Cashu/Mints.tsx b/views/Cashu/Mints.tsx
index 58c369f64..5da1a3c08 100644
--- a/views/Cashu/Mints.tsx
+++ b/views/Cashu/Mints.tsx
@@ -13,6 +13,7 @@ import { NativeStackNavigationProp } from '@react-navigation/native-stack';
 import cloneDeep from 'lodash/cloneDeep';
 
 import Amount from '../../components/Amount';
+import ZeusButton from '../../components/Button';
 import Header from '../../components/Header';
 import MintAvatar from '../../components/MintAvatar';
 import Screen from '../../components/Screen';
@@ -23,20 +24,25 @@ import { localeString } from '../../utils/LocaleUtils';
 import { themeColor } from '../../utils/ThemeUtils';
 
 import CashuStore from '../../stores/CashuStore';
+import SettingsStore from '../../stores/SettingsStore';
 
 import Add from '../../assets/images/SVG/Add.svg';
 
 interface MintsProps {
     navigation: NativeStackNavigationProp<any, any>;
     CashuStore: CashuStore;
-    route: Route<'Mints', { disableRandom?: boolean }>;
+    SettingsStore: SettingsStore;
+    route: Route<
+        'Mints',
+        { disableRandom?: boolean; forceSingleMint?: boolean }
+    >;
 }
 
 interface MintsState {
     mints: any;
 }
 
-@inject('CashuStore')
+@inject('CashuStore', 'SettingsStore')
 @observer
 export default class Mints extends React.Component<MintsProps, MintsState> {
     state = {
@@ -57,10 +63,10 @@ export default class Mints extends React.Component<MintsProps, MintsState> {
         }
     }
 
-    handleFocus = () => {
-        const { CashuStore } = this.props;
+    handleFocus = async () => {
+        const { CashuStore, SettingsStore } = this.props;
         const { cashuWallets, mintUrls, mintInfos, mintBalances } = CashuStore;
-        let mints: any = [];
+        const mints: any = [];
         mintUrls.forEach((mintUrl) => {
             const wallet = cashuWallets[mintUrl];
             const mintInfo = mintInfos[mintUrl];
@@ -75,6 +81,32 @@ export default class Mints extends React.Component<MintsProps, MintsState> {
         this.setState({
             mints
         });
+
+        if (SettingsStore.settings?.ecash?.enableMultiMint) {
+            this.syncMultiMintSelection(mints);
+        }
+    };
+
+    syncMultiMintSelection = async (allMints: any[]) => {
+        const { CashuStore } = this.props;
+
+        const nut15MintUrls = allMints
+            .filter((mint) => mint?.nuts && (mint.nuts[15] || mint.nuts['15']))
+            .map((mint) => mint.mintUrl);
+
+        if (nut15MintUrls.length === 0) {
+            return;
+        }
+
+        const selectedFromStore = CashuStore.selectedMintUrls || [];
+        const validSelection = selectedFromStore.filter((mintUrl) =>
+            nut15MintUrls.includes(mintUrl)
+        );
+
+        const nextSelection =
+            validSelection.length > 0 ? validSelection : nut15MintUrls;
+
+        await CashuStore.setSelectedMintUrls(nextSelection);
     };
 
     renderSeparator = () => (
@@ -87,16 +119,23 @@ export default class Mints extends React.Component<MintsProps, MintsState> {
     );
 
     render() {
-        const { navigation, route, CashuStore } = this.props;
+        const { navigation, CashuStore, SettingsStore, route } = this.props;
         const { mints } = this.state;
         const disableRandom = route?.params?.disableRandom;
         const {
             selectedMintUrl,
+            selectedMintUrls,
             clearInvoice,
             setSelectedMint,
+            setReceiveMint,
+            toggleMintSelection,
             randomizeMintSelection,
             setRandomizeMintSelection
         } = CashuStore;
+        const forceSingleMint = !!route.params?.forceSingleMint;
+        const multiMintEnabled =
+            !!SettingsStore.settings?.ecash?.enableMultiMint &&
+            !forceSingleMint;
 
         const AddMintButton = () => (
             <TouchableOpacity
@@ -134,37 +173,42 @@ export default class Mints extends React.Component<MintsProps, MintsState> {
                         clearInvoice();
                     }}
                 />
-                {!!mints && mints.length > 1 && !disableRandom && (
-                    <View
-                        style={{
-                            flexDirection: 'row',
-                            justifyContent: 'space-between',
-                            alignItems: 'center',
-                            paddingHorizontal: 16,
-                            paddingVertical: 10
-                        }}
-                    >
-                        <Row style={{ flex: 1 }}>
-                            <Text
-                                style={{
-                                    color: themeColor('text'),
-                                    fontFamily: 'PPNeueMontreal-Book',
-                                    fontSize: 16
-                                }}
-                            >
-                                {localeString('cashu.randomizeMintSelection')}
-                            </Text>
-                        </Row>
-                        <Switch
-                            value={randomizeMintSelection}
-                            onValueChange={() =>
-                                setRandomizeMintSelection(
-                                    !randomizeMintSelection
-                                )
-                            }
-                        />
-                    </View>
-                )}
+                {!!mints &&
+                    mints.length > 1 &&
+                    !disableRandom &&
+                    !multiMintEnabled && (
+                        <View
+                            style={{
+                                flexDirection: 'row',
+                                justifyContent: 'space-between',
+                                alignItems: 'center',
+                                paddingHorizontal: 16,
+                                paddingVertical: 10
+                            }}
+                        >
+                            <Row style={{ flex: 1 }}>
+                                <Text
+                                    style={{
+                                        color: themeColor('text'),
+                                        fontFamily: 'PPNeueMontreal-Book',
+                                        fontSize: 16
+                                    }}
+                                >
+                                    {localeString(
+                                        'cashu.randomizeMintSelection'
+                                    )}
+                                </Text>
+                            </Row>
+                            <Switch
+                                value={randomizeMintSelection}
+                                onValueChange={() =>
+                                    setRandomizeMintSelection(
+                                        !randomizeMintSelection
+                                    )
+                                }
+                            />
+                        </View>
+                    )}
                 {!!mints && mints.length > 0 ? (
                     <FlatList
                         data={mints}
@@ -176,11 +220,18 @@ export default class Mints extends React.Component<MintsProps, MintsState> {
                             index: number;
                         }) => {
                             const mintInfo = item._mintInfo || item;
-                            const isSelectedMint =
-                                (!randomizeMintSelection || disableRandom) &&
-                                selectedMintUrl &&
-                                mintInfo?.mintUrl &&
-                                selectedMintUrl === mintInfo?.mintUrl;
+                            const isSelectedMint = multiMintEnabled
+                                ? !!mintInfo?.mintUrl &&
+                                  selectedMintUrls.includes(mintInfo?.mintUrl)
+                                : (!randomizeMintSelection || disableRandom) &&
+                                  selectedMintUrl &&
+                                  mintInfo?.mintUrl &&
+                                  selectedMintUrl === mintInfo?.mintUrl;
+                            const supportsMultinut =
+                                !!mintInfo?.nuts &&
+                                !!(mintInfo.nuts[15] || mintInfo.nuts['15']);
+                            const isDisabled =
+                                multiMintEnabled && !supportsMultinut;
                             const errorConnecting = item.errorConnecting;
                             const hasName = !!mintInfo?.name;
 
@@ -201,15 +252,43 @@ export default class Mints extends React.Component<MintsProps, MintsState> {
                                       )} | ${subTitle}`
                                     : localeString('general.errorConnecting');
                             }
+
+                            if (multiMintEnabled && isDisabled) {
+                                subTitle = `${subTitle} | ${localeString(
+                                    'views.Cashu.Mints.nut15Required'
+                                )}`;
+                            }
+
                             return (
                                 <React.Fragment>
                                     <ListItem
                                         key={`mint-${index}`}
                                         containerStyle={{
                                             borderBottomWidth: 0,
-                                            backgroundColor: 'transparent'
+                                            backgroundColor: 'transparent',
+                                            opacity: isDisabled ? 0.4 : 1
                                         }}
                                         onPress={async () => {
+                                            if (isDisabled) {
+                                                return;
+                                            }
+
+                                            if (multiMintEnabled) {
+                                                await toggleMintSelection(
+                                                    mintInfo?.mintUrl
+                                                );
+                                                return;
+                                            }
+
+                                            if (forceSingleMint) {
+                                                await setReceiveMint(
+                                                    mintInfo?.mintUrl
+                                                ).then(() => {
+                                                    navigation.goBack();
+                                                });
+                                                return;
+                                            }
+
                                             if (
                                                 randomizeMintSelection &&
                                                 !disableRandom
@@ -218,6 +297,7 @@ export default class Mints extends React.Component<MintsProps, MintsState> {
                                                     false
                                                 );
                                             }
+
                                             await setSelectedMint(
                                                 mintInfo?.mintUrl
                                             ).then(() => {
@@ -225,6 +305,30 @@ export default class Mints extends React.Component<MintsProps, MintsState> {
                                             });
                                         }}
                                     >
+                                        {multiMintEnabled && (
+                                            <Icon
+                                                name={
+                                                    isSelectedMint
+                                                        ? 'check-box'
+                                                        : 'check-box-outline-blank'
+                                                }
+                                                color={
+                                                    isDisabled
+                                                        ? themeColor(
+                                                              'secondaryText'
+                                                          )
+                                                        : isSelectedMint
+                                                        ? themeColor(
+                                                              'highlight'
+                                                          )
+                                                        : themeColor(
+                                                              'secondaryText'
+                                                          )
+                                                }
+                                                size={24}
+                                                style={{ marginRight: 10 }}
+                                            />
+                                        )}
                                         <MintAvatar
                                             iconUrl={mintInfo?.icon_url}
                                             name={mintInfo?.name}
@@ -242,6 +346,10 @@ export default class Mints extends React.Component<MintsProps, MintsState> {
                                                                 ? themeColor(
                                                                       'error'
                                                                   )
+                                                                : isDisabled
+                                                                ? themeColor(
+                                                                      'secondaryText'
+                                                                  )
                                                                 : isSelectedMint
                                                                 ? themeColor(
                                                                       'highlight'
@@ -327,6 +435,26 @@ export default class Mints extends React.Component<MintsProps, MintsState> {
                         }}
                     />
                 )}
+                {multiMintEnabled && (
+                    <View
+                        style={{
+                            position: 'absolute',
+                            left: 0,
+                            right: 0,
+                            bottom: 15,
+                            paddingHorizontal: 16,
+                            backgroundColor: 'transparent',
+                            zIndex: 20
+                        }}
+                    >
+                        <ZeusButton
+                            title={localeString('general.confirm')}
+                            onPress={() => navigation.goBack()}
+                            containerStyle={{ marginTop: 15 }}
+                            noUppercase
+                        />
+                    </View>
+                )}
             </Screen>
         );
     }
diff --git a/views/Cashu/MultimintPayment.tsx b/views/Cashu/MultimintPayment.tsx
new file mode 100644
index 000000000..40e761942
--- /dev/null
+++ b/views/Cashu/MultimintPayment.tsx
@@ -0,0 +1,516 @@
+import * as React from 'react';
+import {
+    ActivityIndicator,
+    Dimensions,
+    FlatList,
+    StyleSheet,
+    Text,
+    View
+} from 'react-native';
+import { inject, observer } from 'mobx-react';
+import { Route } from '@react-navigation/native';
+import { NativeStackNavigationProp } from '@react-navigation/native-stack';
+import { Icon, ListItem } from '@rneui/themed';
+
+import Amount from '../../components/Amount';
+import Button from '../../components/Button';
+import Header from '../../components/Header';
+import PaidIndicator from '../../components/PaidIndicator';
+import Screen from '../../components/Screen';
+import SuccessAnimation from '../../components/SuccessAnimation';
+
+import CashuStore from '../../stores/CashuStore';
+
+import {
+    MintPaymentStatus,
+    MintProgressInfo,
+    MultinutPaymentStep
+} from '../../utils/CashuUtils';
+import { localeString } from '../../utils/LocaleUtils';
+import { themeColor } from '../../utils/ThemeUtils';
+import UrlUtils from '../../utils/UrlUtils';
+
+import ErrorIcon from '../../assets/images/SVG/ErrorIcon.svg';
+import Wordmark from '../../assets/images/SVG/wordmark-black.svg';
+
+interface MultimintPaymentProps {
+    navigation: NativeStackNavigationProp<any, any>;
+    route: Route<'MultimintPayment', { paymentAmount?: string }>;
+    CashuStore?: CashuStore;
+}
+
+interface MultimintPaymentState {
+    mints: MintProgressInfo[];
+    totalSelectedBalance: number;
+    step: MultinutPaymentStep;
+    isProcessing: boolean;
+    error?: string;
+}
+
+@inject('CashuStore')
+@observer
+export default class MultimintPayment extends React.Component<
+    MultimintPaymentProps,
+    MultimintPaymentState
+> {
+    constructor(props: MultimintPaymentProps) {
+        super(props);
+
+        const { CashuStore, route } = props;
+        const selectedMintUrls = CashuStore?.selectedMintUrls || [];
+        const selectedMintSet = new Set(selectedMintUrls);
+        const availableMints = CashuStore?.getMultimintInfo() || [];
+
+        const selectedMints =
+            selectedMintUrls.length > 0
+                ? availableMints.filter((mint) =>
+                      selectedMintSet.has(mint.mintUrl)
+                  )
+                : availableMints;
+        const effectiveMints =
+            selectedMints.length > 0 ? selectedMints : availableMints;
+
+        const totalSelectedBalance = effectiveMints.reduce(
+            (sum, mint) => sum + Number(mint.balance || 0),
+            0
+        );
+
+        const requestAmount =
+            CashuStore?.payReq?.getRequestAmount ||
+            Number(route.params?.paymentAmount || 0);
+        const feeEstimate = Number(CashuStore?.feeEstimate) || 0;
+        const totalNeeded = requestAmount + feeEstimate;
+
+        const hasNoMintsSelected = effectiveMints.length === 0;
+        const hasInsufficientBalance =
+            totalNeeded > totalSelectedBalance && totalSelectedBalance > 0;
+
+        this.state = {
+            mints: effectiveMints,
+            totalSelectedBalance,
+            step:
+                hasNoMintsSelected || hasInsufficientBalance
+                    ? MultinutPaymentStep.FAILED
+                    : MultinutPaymentStep.PROCESSING,
+            isProcessing: false,
+            error: hasNoMintsSelected
+                ? localeString('views.Cashu.MultimintPayment.noMintsSelected')
+                : hasInsufficientBalance
+                ? localeString('stores.CashuStore.notEnoughFunds')
+                : undefined
+        };
+    }
+
+    componentDidMount(): void {
+        if (this.state.step !== MultinutPaymentStep.FAILED) {
+            this.executePayment();
+        }
+    }
+
+    onProgressUpdate = (progressInfo: {
+        step: MultinutPaymentStep;
+        mints: MintProgressInfo[];
+        totalSelectedBalance: number;
+        isProcessing: boolean;
+    }) => {
+        this.setState((prev) => ({
+            mints: prev.mints.map((mint) => {
+                const updated = progressInfo.mints.find(
+                    (item) => item.mintUrl === mint.mintUrl
+                );
+                return updated ? { ...mint, ...updated } : mint;
+            }),
+            totalSelectedBalance:
+                progressInfo.totalSelectedBalance ?? prev.totalSelectedBalance,
+            isProcessing: progressInfo.isProcessing ?? prev.isProcessing,
+            step: progressInfo.step || prev.step,
+            error:
+                progressInfo.step === MultinutPaymentStep.FAILED
+                    ? prev.error
+                    : undefined
+        }));
+    };
+
+    executePayment = async () => {
+        const { CashuStore, route } = this.props;
+
+        try {
+            this.setState((prev) => ({
+                step: MultinutPaymentStep.PROCESSING,
+                isProcessing: true,
+                error: undefined,
+                mints: prev.mints.map((mint) => ({
+                    ...mint,
+                    status: MintPaymentStatus.IDLE,
+                    error: undefined
+                }))
+            }));
+
+            const payment = await CashuStore!!.payLnInvoiceFromEcash({
+                amount: route.params?.paymentAmount
+            });
+
+            if (!payment || CashuStore!!.paymentError) {
+                this.setState({
+                    step: MultinutPaymentStep.FAILED,
+                    isProcessing: false,
+                    error:
+                        CashuStore!!.paymentErrorMsg ||
+                        localeString('stores.CashuStore.errorPayingInvoice')
+                });
+                return;
+            }
+
+            this.setState({
+                step: MultinutPaymentStep.COMPLETE,
+                isProcessing: false,
+                error: undefined
+            });
+        } catch (error: any) {
+            this.setState({
+                step: MultinutPaymentStep.FAILED,
+                isProcessing: false,
+                error:
+                    error?.message ||
+                    localeString('stores.CashuStore.errorPayingInvoice')
+            });
+        }
+    };
+
+    renderSeparator = () => (
+        <View
+            style={{
+                height: 0.4,
+                backgroundColor: themeColor('separator')
+            }}
+        />
+    );
+
+    renderMintItem = ({ item }: { item: MintProgressInfo }) => {
+        const { isProcessing } = this.state;
+
+        const getSubtitle = () => {
+            if (item.status === MintPaymentStatus.SUCCESS) {
+                return `${localeString('general.success')} | ${item.mintUrl}`;
+            }
+            if (item.status === MintPaymentStatus.FAILED) {
+                return `${localeString('general.failed')} | ${
+                    item.error || item.mintUrl
+                }`;
+            }
+            if (item.status === MintPaymentStatus.PAYING && isProcessing) {
+                return `${localeString(
+                    'views.Cashu.MultimintPayment.paying'
+                )} | ${item.mintUrl}`;
+            }
+            if (item.status === MintPaymentStatus.REQUESTING && isProcessing) {
+                return `${localeString(
+                    'views.Cashu.MultimintPayment.requesting'
+                )} | ${item.mintUrl}`;
+            }
+            return item.mintUrl;
+        };
+
+        return (
+            <ListItem
+                containerStyle={{
+                    borderBottomWidth: 0,
+                    backgroundColor: 'transparent'
+                }}
+            >
+                {(item.status === MintPaymentStatus.PAYING ||
+                    item.status === MintPaymentStatus.REQUESTING) && (
+                    <ActivityIndicator
+                        size="small"
+                        color={themeColor('highlight')}
+                        style={{ marginRight: 10 }}
+                    />
+                )}
+
+                {item.status === MintPaymentStatus.SUCCESS && (
+                    <Icon
+                        name="check-circle"
+                        color={themeColor('success')}
+                        size={20}
+                        style={{ marginRight: 10 }}
+                    />
+                )}
+
+                {item.status === MintPaymentStatus.FAILED && (
+                    <Icon
+                        name="error"
+                        color={themeColor('error')}
+                        size={20}
+                        style={{ marginRight: 10 }}
+                    />
+                )}
+
+                <ListItem.Content>
+                    <ListItem.Title
+                        style={{
+                            color: themeColor('text'),
+                            fontSize: 18,
+                            fontFamily: 'PPNeueMontreal-Book'
+                        }}
+                    >
+                        {item.mintName}
+                    </ListItem.Title>
+                    <ListItem.Subtitle
+                        style={{
+                            color: themeColor('secondaryText'),
+                            fontSize: 12,
+                            fontFamily: 'Lato-Regular',
+                            flexWrap: 'wrap',
+                            flexShrink: 1
+                        }}
+                    >
+                        {getSubtitle()}
+                    </ListItem.Subtitle>
+                </ListItem.Content>
+                <Amount sats={item.balance} sensitive />
+            </ListItem>
+        );
+    };
+
+    render() {
+        const { navigation, CashuStore, route } = this.props;
+        const { mints, totalSelectedBalance, step, error } = this.state;
+        const windowSize = Dimensions.get('window');
+
+        const paymentAmount =
+            CashuStore?.payReq?.getRequestAmount ||
+            Number(route.params?.paymentAmount || 0);
+
+        const hasError =
+            step === MultinutPaymentStep.FAILED ||
+            !!error ||
+            !!CashuStore?.paymentError;
+        const errorMessage = error || CashuStore?.paymentErrorMsg;
+
+        return (
+            <Screen>
+                <Header
+                    leftComponent="Back"
+                    centerComponent={{
+                        text: localeString('views.SendingLightning.sending'),
+                        style: {
+                            color: themeColor('text'),
+                            fontFamily: 'PPNeueMontreal-Book'
+                        }
+                    }}
+                    navigation={navigation}
+                />
+
+                <View style={styles.container}>
+                    {hasError ? (
+                        <View
+                            style={{
+                                ...styles.statusWrap,
+                                paddingTop: windowSize.height * 0.05
+                            }}
+                        >
+                            <ErrorIcon
+                                width={windowSize.height * 0.13}
+                                height={windowSize.height * 0.13}
+                            />
+                            <Text
+                                style={{
+                                    color: themeColor('warning'),
+                                    fontFamily: 'PPNeueMontreal-Book',
+                                    fontSize: 32,
+                                    marginTop: 24
+                                }}
+                            >
+                                {localeString('general.error')}
+                            </Text>
+                            {!!errorMessage && (
+                                <Text
+                                    style={{
+                                        color: themeColor('warning'),
+                                        textAlign: 'center',
+                                        fontFamily: 'PPNeueMontreal-Book',
+                                        marginTop: 8,
+                                        paddingHorizontal: 12
+                                    }}
+                                >
+                                    {errorMessage}
+                                </Text>
+                            )}
+                        </View>
+                    ) : (
+                        <View
+                            style={{
+                                ...styles.statusWrap,
+                                paddingTop: windowSize.height * 0.05
+                            }}
+                        >
+                            <Wordmark
+                                height={windowSize.width * 0.25}
+                                width={windowSize.width}
+                                fill={themeColor('highlight')}
+                            />
+
+                            {step === MultinutPaymentStep.COMPLETE && (
+                                <>
+                                    <PaidIndicator />
+                                    <SuccessAnimation />
+                                    <Text
+                                        style={{
+                                            color: themeColor('text'),
+                                            paddingTop: 12,
+                                            fontFamily: 'PPNeueMontreal-Book',
+                                            fontSize: 18
+                                        }}
+                                    >
+                                        {localeString(
+                                            'views.SendingLightning.success'
+                                        )}
+                                    </Text>
+                                </>
+                            )}
+
+                            <View style={{ marginTop: 10, marginBottom: 8 }}>
+                                <Amount
+                                    sats={paymentAmount}
+                                    sensitive
+                                    toggleable
+                                    jumboText
+                                />
+                            </View>
+
+                            <View
+                                style={{
+                                    flexDirection: 'row',
+                                    alignItems: 'center'
+                                }}
+                            >
+                                <Text
+                                    style={{
+                                        color: themeColor('secondaryText'),
+                                        marginRight: 6,
+                                        fontFamily: 'PPNeueMontreal-Book'
+                                    }}
+                                >
+                                    {localeString(
+                                        'views.Cashu.MultimintPayment.totalAvailable'
+                                    )}
+                                </Text>
+                                <Amount
+                                    sats={totalSelectedBalance}
+                                    sensitive
+                                    color="secondaryText"
+                                />
+                            </View>
+                        </View>
+                    )}
+
+                    <FlatList
+                        data={mints}
+                        renderItem={this.renderMintItem}
+                        keyExtractor={(item) => item.mintUrl}
+                        style={styles.mintsList}
+                        showsVerticalScrollIndicator={false}
+                        ItemSeparatorComponent={this.renderSeparator}
+                    />
+                </View>
+
+                <View style={styles.bottomSection}>
+                    {step === MultinutPaymentStep.PROCESSING && !hasError && (
+                        <Button
+                            title={localeString('general.cancel')}
+                            onPress={() => navigation.goBack()}
+                            noUppercase
+                        />
+                    )}
+
+                    {step !== MultinutPaymentStep.PROCESSING &&
+                        !hasError &&
+                        CashuStore?.noteKey && (
+                            <Button
+                                title={localeString(
+                                    'views.SendingLightning.AddANote'
+                                )}
+                                onPress={() =>
+                                    navigation.navigate('AddNotes', {
+                                        noteKey: CashuStore.noteKey
+                                    })
+                                }
+                                secondary
+                            />
+                        )}
+
+                    {hasError && (
+                        <>
+                            <Button
+                                title={localeString(
+                                    'views.SendingLightning.tryAgain'
+                                )}
+                                icon={{
+                                    name: 'rotate-ccw',
+                                    type: 'feather',
+                                    size: 25
+                                }}
+                                onPress={() => navigation.goBack()}
+                                secondary
+                            />
+                            <Button
+                                title={localeString(
+                                    'views.Settings.Ecash.cashuTroubleshooting'
+                                )}
+                                icon={{
+                                    name: 'life-buoy',
+                                    type: 'feather',
+                                    size: 25
+                                }}
+                                onPress={() => {
+                                    UrlUtils.goToUrl(
+                                        'https://docs.zeusln.app/cashu#i-get-an-error-saying-outputs-have-already-been-signed-before-or-already-spent-what-should-i-do'
+                                    );
+                                }}
+                                secondary
+                            />
+                        </>
+                    )}
+
+                    {step !== MultinutPaymentStep.PROCESSING && (
+                        <Button
+                            title={localeString(
+                                'views.SendingLightning.goToWallet'
+                            )}
+                            icon={{
+                                name: 'list',
+                                size: 25,
+                                color: themeColor('background')
+                            }}
+                            onPress={() => navigation.popTo('Wallet')}
+                            buttonStyle={{ height: 40 }}
+                            titleStyle={{ color: themeColor('background') }}
+                        />
+                    )}
+                </View>
+            </Screen>
+        );
+    }
+}
+
+const styles = StyleSheet.create({
+    container: {
+        flex: 1,
+        paddingHorizontal: 20
+    },
+    statusWrap: {
+        alignItems: 'center',
+        justifyContent: 'space-evenly'
+    },
+    mintsList: {
+        flex: 1,
+        marginBottom: 20,
+        marginTop: 10
+    },
+    bottomSection: {
+        width: '100%',
+        justifyContent: 'space-between',
+        gap: 15,
+        bottom: 15
+    }
+});
diff --git a/views/Cashu/ReceiveEcash.tsx b/views/Cashu/ReceiveEcash.tsx
index 6bc8bb898..fca4cf7de 100644
--- a/views/Cashu/ReceiveEcash.tsx
+++ b/views/Cashu/ReceiveEcash.tsx
@@ -641,6 +641,7 @@ export default class ReceiveEcash extends React.Component<
                                                             overrideMintUrl={
                                                                 lastInvoiceMintUrl
                                                             }
+                                                            isReceiveView
                                                             navigation={
                                                                 navigation
                                                             }
@@ -791,6 +792,7 @@ export default class ReceiveEcash extends React.Component<
                                             >
                                                 <EcashMintPicker
                                                     hideAmount
+                                                    isReceiveView
                                                     navigation={navigation}
                                                 />
                                             </View>
diff --git a/views/Settings/EcashSettings.tsx b/views/Settings/EcashSettings.tsx
index 40369e120..e9e060203 100644
--- a/views/Settings/EcashSettings.tsx
+++ b/views/Settings/EcashSettings.tsx
@@ -31,6 +31,7 @@ interface EcashSettingsProps {
 interface EcashSettingsState {
     loading: boolean;
     enableCashu: boolean;
+    enableMultiMint: boolean;
     automaticallySweep: boolean;
     sweepThresholdSats: string;
 }
@@ -44,6 +45,7 @@ export default class EcashSettings extends React.Component<
     state = {
         loading: false,
         enableCashu: false,
+        enableMultiMint: false,
         automaticallySweep: false,
         sweepThresholdSats: '0'
     };
@@ -59,6 +61,11 @@ export default class EcashSettings extends React.Component<
                 settings?.ecash?.enableCashu !== undefined
                     ? settings.ecash.enableCashu
                     : false,
+            enableMultiMint:
+                settings?.ecash?.enableMultiMint !== null &&
+                settings?.ecash?.enableMultiMint !== undefined
+                    ? settings.ecash.enableMultiMint
+                    : false,
             automaticallySweep:
                 settings?.ecash?.automaticallySweep !== null &&
                 settings?.ecash?.automaticallySweep !== undefined
@@ -98,8 +105,13 @@ export default class EcashSettings extends React.Component<
     render() {
         const { navigation, CashuStore, ChannelsStore, SettingsStore } =
             this.props;
-        const { loading, enableCashu, automaticallySweep, sweepThresholdSats } =
-            this.state;
+        const {
+            loading,
+            enableCashu,
+            enableMultiMint,
+            automaticallySweep,
+            sweepThresholdSats
+        } = this.state;
         const { settings, updateSettings }: any = SettingsStore;
         const hasOpenChannels = ChannelsStore.channels.length > 0;
 
@@ -167,13 +179,19 @@ export default class EcashSettings extends React.Component<
                                     await updateSettings({
                                         ecash: {
                                             ...settings.ecash,
-                                            enableCashu: !enableCashu
+                                            enableCashu: !enableCashu,
+                                            enableMultiMint: !enableCashu
+                                                ? enableMultiMint
+                                                : false
                                         }
                                     });
                                     if (!enableCashu) {
                                         await CashuStore.initializeWallets();
                                     }
                                     this.setState({
+                                        enableMultiMint: !enableCashu
+                                            ? enableMultiMint
+                                            : false,
                                         loading: false
                                     });
                                 }}
@@ -185,6 +203,60 @@ export default class EcashSettings extends React.Component<
                         </View>
                     </View>
 
+                    <View style={{ flexDirection: 'row', marginTop: 20 }}>
+                        <View
+                            style={{
+                                flex: 1,
+                                justifyContent: 'center'
+                            }}
+                        >
+                            <Text
+                                style={{
+                                    color: enableCashu
+                                        ? themeColor('text')
+                                        : 'gray',
+                                    fontSize: 17
+                                }}
+                            >
+                                {localeString(
+                                    'views.Settings.Ecash.enableMultiMintSends'
+                                )}
+                            </Text>
+                        </View>
+                        <View
+                            style={{
+                                alignSelf: 'center',
+                                marginLeft: 5
+                            }}
+                        >
+                            <Switch
+                                value={enableMultiMint}
+                                onValueChange={async () => {
+                                    this.setState({
+                                        enableMultiMint: !enableMultiMint,
+                                        loading: true
+                                    });
+
+                                    await updateSettings({
+                                        ecash: {
+                                            ...settings.ecash,
+                                            enableMultiMint: !enableMultiMint
+                                        }
+                                    });
+
+                                    this.setState({
+                                        loading: false
+                                    });
+                                }}
+                                disabled={
+                                    !enableCashu ||
+                                    SettingsStore.settingsUpdateInProgress ||
+                                    loading
+                                }
+                            />
+                        </View>
+                    </View>
+
                     <View
                         style={{
                             marginTop: 20,