Ludo In-App Purchases: Platform Integration Guide

// Initialize billing client
val billingClient = BillingClient.newBuilder(context)
    .setListener(purchasesUpdatedListener)
    .enablePendingPurchases()
    .build()

billingClient.startConnection(object : BillingClientStateListener {
    override fun onBillingSetupFinished(result: BillingResult) {
        if (result.responseCode == BillingClient.BillingResponseCode.OK) {
            queryAvailableProducts()
        }
    }
    override fun onBillingServiceDisconnected() {
        // Retry connection with exponential backoff
    }
})

// Query available products
fun queryAvailableProducts() {
    val params = QueryProductDetailsParams.newBuilder()
        .setProductList(
            listOf(
                ProductDetails.newBuilder()
                    .setProductId("coins_100")
                    .setProductType(BillingClient.ProductType.INAPP)
                    .build(),
                ProductDetails.newBuilder()
                    .setProductId("coins_1000")
                    .setProductType(BillingClient.ProductType.INAPP)
                    .build(),
                ProductDetails.newBuilder()
                    .setProductId("vip_pass_monthly")
                    .setProductType(BillingClient.ProductType.SUBS)
                    .build()
            )
        )
        .build()

    billingClient.queryProductDetails(params) { result ->
        val productDetailsList = result.productDetailsList
        // Display products in your game's shop UI
    }
}

import StoreKit

// Request and process a purchase
@MainActor
func purchase(product: Product) async throws -> Transaction? {
    let result = try await product.purchase()

    switch result {
    case .success(let verification):
        let transaction = try checkVerified(verification)
        await updateServerWithPurchase(transaction: transaction)
        await transaction.finish()
        return transaction

    case .userCancelled:
        return nil

    case .pending:
        return nil

    @unknown default:
        return nil
    }
}

// Server-side validation
func updateServerWithPurchase(transaction: Transaction) async {
    let body: [String: Any] = [
        "player_id": currentPlayer.id,
        "product_id": transaction.productID,
        "transaction_id": String(transaction.id),
        "original_transaction_id": String(transaction.originalID ?? transaction.id),
        "app_account_token": transaction.appAccountToken?.uuidString ?? "",
        "environment": "sandbox"  // or "production"
    ]

    guard let url = URL(string: "https://api.ludokingapi.com/v1/iap/validate/apple") else { return }
    var request = URLRequest(url: url)
    request.httpMethod = "POST"
    request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
    request.setValue("application/json", forHTTPHeaderField: "Content-Type")
    request.httpBody = try? JSONSerialization.data(withJSONObject: body)

    let (_, response) = try await URLSession.shared.data(for: request)
    // Handle response and credit player wallet
}

// Backend: Create Stripe Checkout Session
const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY);

app.post('/api/v1/iap/create-checkout', async (req, res) => {
  const { player_id, product_id, coin_amount } = req.body;

  const session = await stripe.checkout.sessions.create({
    payment_method_types: ['card'],
    line_items: [{
      price_data: {
        currency: 'usd',
        product_data: {
          name: `${coin_amount} Ludo Coins`,
          description: 'Virtual currency for Ludo King game'
        },
        unit_amount: getPriceInCents(product_id)  // e.g., 499 for $4.99
      },
      quantity: 1
    }],
    mode: 'payment',
    success_url: `https://yourgame.com/shop/success?session_id={CHECKOUT_SESSION_ID}`,
    cancel_url: 'https://yourgame.com/shop',
    metadata: {
      player_id,
      product_id,
      coin_amount,
      idempotency_key: `${player_id}_${product_id}_${Date.now()}`
    },
    customer_email: req.user?.email  // if available
  });

  res.json({ checkout_url: session.url });
});

// Webhook: Handle payment confirmation
app.post('/webhook/stripe', express.raw({type: 'application/json'}), async (req, res) => {
  const sig = req.headers['stripe-signature'];
  const event = stripe.webhooks.constructEvent(req.body, sig, process.env.STRIPE_WEBHOOK_SECRET);

  if (event.type === 'checkout.session.completed') {
    const session = event.data.object;
    await creditPlayerWallet({
      player_id: session.metadata.player_id,
      coins: parseInt(session.metadata.coin_amount),
      transaction_ref: session.id
    });
  }

  res.json({ received: true });
});

{
  "player_id": "player_7x4k9m2p",
  "platform": "google_play",  // google_play | app_store | stripe
  "receipt_data": "MIIXxAYJKoZIhvcNAQcCoIIXtTCCF7ECAQExDDA...",
  "purchase_token": "gpak.token.here...",
  "product_id": "coins_1000",
  "client_txn_id": "purchase_client_1705768200",
  "signature": "android_signature_here"
}

// Response — successful validation
{
  "status": "valid",
  "validated_at": "2025-01-20T10:35:42Z",
  "product_id": "coins_1000",
  "coins_awarded": 1000,
  "wallet_new_balance": 6000,
  "transaction_id": "txn_9f3k2m8p",
  "duplicate": false
}