stripe-kmm

Implements Stripe payment processing with support for iDEAL, Card, UPI, and CashApp. Features initialization, payment method creation, payment confirmation, and handling next actions for authentication.

#swift
#service-sdk
#sdk
#client
#apple

Suggest an edit

Android JVMKotlin/Native

GitHub stars9

Authorsqburst

Open issues4

Creation dateover 1 year ago

Last activity10 months ago

Latest release1.0.1 (about 1 year ago)

GitHub repository

Stripe KMM Integration

This repository provides an implementation of Stripe Payment using Kotlin Multiplatform Mobile (KMM). It supports multiple payment methods, including iDEAL, Card, UPI, and CashApp.

🚀 Features

Initialize Stripe SDK with a publishable key
Create Payment Methods for different payment options
Confirm Payment and handle next actions
Support for multiple payment methods (Card, iDEAL, UPI, CashApp)

📌 Installation

Shared Module Setup

Add Dependencies
Add the Stripe KMM dependency in your shared module's build.gradle.kts under commonMain:

kotlin {
    sourceSets {
        commonMain {
            dependencies {
                implementation("io.github.qburst.stripekmm:<version>")
            }
        }
    }
}

iOS Setup

Add Shared Dependency
- Ensure the shared module dependency is properly set up in your iOS project
- The shared module containing the Stripe KMM implementation will be automatically available
Add Swift Package
- Open your iOS project in Xcode
- Go to File → Add Package Dependencies
- Add SwiftKMMStripeKit
- Click on "Add Package"

📖 Usage

1️⃣ Initialize Stripe SDK

Before making any payments, initialize the Stripe SDK with your publishable key:

val stripe = ProvideStripeSdk()

val initialiseParams = InitialiseParams(
    publishableKey = "<your_publishable_key>",
    appInfo = AppInfo(
        name = "<your_app_name>",
        version = "<your_app_version>",
        partnerId = "<your_partner_id>",
        url = "<your_app_url>",
    )
)

// Initialize Stripe
CoroutineScope(Dispatchers.Default).launch {
    stripe.initialise(initialiseParams)
}

2️⃣ Collect Billing Details

Before proceeding with payment, collect user billing details:

val billingDetails = BillingDetails(
    name = "<customer_name>",
    email = "<customer_email>",
    phone = "<customer_phone>"
)

3️⃣ Choose a Payment Method

The app provides different payment methods. The user selects one from:

iDEAL
Card
UPI
CashApp

var selectedMethod by remember { mutableStateOf("") }

4️⃣ Create Payment Method

Once the user provides the necessary details, create the payment method:

CoroutineScope(Dispatchers.Default).launch {
    stripe.createPaymentMethod(
        params = when(selectedMethod) {
            "Ideal" -> {
                CreateParams.IdealParams(
                    paymentMethodData = CreateParams.PaymentMethodDataIdeal(
                        bankName = "<ideal_bank_name>",
                        billingDetails = billingDetails
                    )
                )
            }
            "Card" -> {
                CreateParams.CardParamsWithToken(
                    paymentMethodData = CreateParams.PaymentMethodDataWithToken(
                        token = "<card_token>",
                        billingDetails = billingDetails
                    )
                )
            }
            "Upi" -> {
                CreateParams.UpiParams(
                    paymentMethodData = CreateParams.PaymentMethodDataUpi(
                        vpa = "<upi_vpa>",
                        billingDetails = billingDetails
                    )
                )
            }
            "CashApp" -> {
                CreateParams.CashAppParams(
                    paymentMethodData = CreateParams.PaymentMethodDataCashApp(
                        billingDetails = billingDetails
                    )
                )
            }
            else -> throw IllegalStateException("Invalid payment method selected")
        },
        options = CreateOptions(FutureUsage.OFF_SESSION),
        onSuccess = { result ->
            println("Payment Method Created: $result")
        },
        onError = { error ->
            println("Error: $error")
        }
    )
}

5️⃣ Confirm Payment

Once a payment method is created, confirm the payment:

CoroutineScope(Dispatchers.Default).launch {
    stripe.confirmPayment(
        paymentIntentClientSecret = "<payment_intent_client_secret>",
        params = ConfirmParams.CardParamsWithToken(
            paymentMethodData = ConfirmParams.PaymentMethodDataWithToken(
                token = "<card_token>",
                billingDetails = billingDetails
            )
        ),
        options = CreateOptions(FutureUsage.OFF_SESSION),
        onSuccess = { result ->
            println("Payment Confirmed: $result")
        },
        onError = { error ->
            println("Error: $error")
        }
    )
}

6️⃣ Handle Next Actions (If Required)

Sometimes, additional steps are required for authentication (e.g., 3D Secure). In such cases, handle next actions:

CoroutineScope(Dispatchers.Default).launch {
    stripe.handleNextAction(
        paymentIntentClientSecret = "<payment_intent_client_secret>",
        returnURL = "<your_return_url>",
        onSuccess = { result ->
            println("Next Action Handled: $result")
        },
        onError = { error ->
            println("Error: $error")
        }
    )
}

🛠️ Customization

You can customize the following parameters:

Billing Details (BillingDetails(name, email, phone))
Payment Options (CreateOptions(FutureUsage.OFF_SESSION))
Return URL (<your_return_url>)
Publishable Key (<your_publishable_key>)

📌 Notes

Ensure you replace placeholders (<your_publishable_key>, <payment_intent_client_secret>, <your_return_url>) with your actual credentials
Test using Stripe Test Cards from Stripe Docs
You must handle 3D Secure authentication (if required)

📜 License

This project is licensed under the MIT License.

📞 Support

For issues and support, open an issue on the repository or check Stripe Documentation:

🔗 Stripe Docs