Implementation

import PXPCheckoutSDK

{callbackScheme}://paze

<key>CFBundleURLTypes</key>
<array>
  <dict>
    <key>CFBundleURLSchemes</key>
    <array>
      <string>pxpcheckout</string>
    </array>
  </dict>
</array>

{
  "merchant": "MERCHANT-1",
  "site": "SITE-1",
  "sessionTimeout": 120,
  "merchantTransactionId": "txn-123",
  "transactionMethod": {
    "intent": {
      "card": "Authorisation"
    }
  },
  "amounts": {
    "currencyCode": "USD",
    "transactionValue": 99.99
  },
  "allowTransaction": true
}

curl -i -X POST \
  'https://api-services.dev.pxp.io/api/v1/sessions' \
  -H 'Authorization: PXP-UST1 9aac6071-38d0-4545-9d2f-15b936af6d7f:1754701373:1DE2DFC390D7CD746A972140F26846AFA81CF85F5A0BAABA95DBC95301795EA6' \
  -H 'X-Request-Id: ce244054-b372-42c2-9102-f0d976db69f6' \
  -H 'X-Client-Id: f47ac10b-58cc-4372-a567-0e02b2c3d479' \
  -H 'Content-Type: application/json' \
  -d '{
  "merchant": "MERCHANT-1",
  "site": "SITE-1",
  "sessionTimeout": 120,
  "merchantTransactionId": "txn-123",
  "transactionMethod": {
    "intent": {
      "card": "Authorisation"
    }
  },
  "amounts": {
    "currencyCode": "USD",
    "transactionValue": 99.99
  },
  "allowTransaction": true
}'

{
  "sessionId": "c5f0799b-0839-43ce-abc5-5b462a98f250",
  "hmacKey": "904bc42395d4af634e2fd48ee8c2c7f52955a1da97a3aa3d82957ff12980a7bb",
  "encryptionKey": "20d175a669ad3f8c195c9c283fc86155",
  "sessionExpiry": "2025-05-19T13:39:20.3843454Z",
  "allowedFundingTypes": {
    "cardSchemes": ["Visa", "Mastercard", "AmericanExpress"],
    "cards": [],
    "wallets": {
      "paze": {
        "clientId": "your-paze-client-id",
        "profileId": "optional-profile-id",
        "merchantCategoryCode": "5812"
      }
    }
  }
}

import PXPCheckoutSDK

// Session data from your backend
let sessionData = SessionData(
    sessionId: session.sessionId,
    hmacKey: session.hmacKey,
    encryptionKey: session.encryptionKey,
    allowedFundingTypes: AllowedFundingType(
        wallets: Wallets(
            paze: Paze(
                clientId: session.pazeClientId,
                profileId: session.pazeProfileId,
                merchantCategoryCode: session.merchantCategoryCode
            )
        )
    )
)

let merchantTransactionId = session.merchantTransactionId

let transactionData = TransactionData(
    amount: 99.99,
    currency: "USD",
    entryType: .ecom,
    intent: TransactionIntentData(card: .authorisation),
    merchantTransactionId: merchantTransactionId,
    merchantTransactionDate: { Date() }
)

let checkoutConfig = CheckoutConfig(
    environment: .test,
    session: sessionData,
    transactionData: transactionData,
    merchantShopperId: "shopper-123",
    ownerId: "MERCHANT-GROUP-1",
    clientName: "Your Merchant",
    siteName: "Your Store",
    onGetShopper: { async in
        TransactionShopper(
            id: "shopper-123",
            firstName: "John",
            lastName: "Doe",
            email: "customer@example.com"
        )
    },
    analyticsEvent: { event in
        print("Analytics: \(event.eventName)")
    }
)

let pxpCheckout = try PxpCheckout.initialize(config: checkoutConfig)

let config = PazeButtonComponentConfig()
config.emailAddress = "customer@example.com"
config.phoneNumber = "15551234567"
config.paymentDescription = "Order #12345"
config.billingPreference = .all
config.performAVS = true
config.style = PazeButtonStyleConfig(
    color: .auto,
    shape: .rounded,
    label: .checkoutWith
)

config.onPresentmentResolved = { isVisible in
    print("Paze button visible:", isVisible)
}

config.onCheckoutComplete = { _ async in
  // Return true to approve checkout and continue to complete/decrypt/authorise
  return true
}

config.onPostAuthorisation = { result async in
    // CRITICAL: Verify transaction outcome on backend before fulfilling order
    await verifyPaymentOnBackend(systemTransactionId: result.systemTransactionId)
}

config.onSubmitError = { submitError async in
    if let failed = submitError as? FailedSubmitResult {
        print("Authorisation failed:", failed.errorReason ?? "")
    }
}

config.onError = { error in
    print("Paze error [\(error.errorCode)]: \(error.errorMessage)")
}

let pazeButton = try pxpCheckout.create(.pazeButton, componentConfig: config)

struct CheckoutView: View {
    @State private var pazeButton: BaseComponent?

    var body: some View {
        VStack {
            if let pazeButton {
                pazeButton.buildContent()
                    .frame(maxWidth: .infinity)
            } else {
                ProgressView("Loading Paze...")
            }
        }
        .onAppear {
            Task { await loadPazeButton() }
        }
    }

    private func loadPazeButton() async {
        // Initialise pxpCheckout and create component (see steps 4–5)
    }
}

let checkoutConfig = CheckoutConfig(
    // ... session and transactionData
    onGetShopper: { async in
        TransactionShopper(
            id: "shopper-123",
            firstName: "John",
            lastName: "Doe",
            email: "customer@example.com"
        )
    }
)

config.onCheckoutComplete = { _ async in true }

config.onPreDecryption = { async in false }

config.onComplete = { result async in
    guard let securedPayload = result.completeDecodedResponse?.securedPayload else { return }

  // Call your backend — never call the PXP decrypt API directly from the app
    await sendToBackendForDecryption(securedPayload: securedPayload)
}

{
  "site": "your-site-id",
  "token": "eyJhdWQHBmaW..."
}

import SwiftUI
import PXPCheckoutSDK

struct PazeCheckoutView: View {
    @State private var pxpCheckout: PxpCheckout?
    @State private var pazeButton: BaseComponent?
    @State private var isLoading = true
    @State private var errorMessage: String?

    var body: some View {
        VStack(spacing: 16) {
            if isLoading {
                ProgressView("Connecting...")
            } else if let errorMessage {
                Text(errorMessage).foregroundColor(.red)
            } else if let pazeButton {
                pazeButton.buildContent()
                    .frame(maxWidth: .infinity)
            }
        }
        .padding()
        .onAppear { Task { await setupPaze() } }
    }

    private func setupPaze() async {
        do {
            let session = try await fetchSessionFromBackend()
            let checkout = try createPxpCheckout(session: session)
            let config = buildPazeConfig()
            let component = try checkout.create(.pazeButton, componentConfig: config)

            await MainActor.run {
                self.pxpCheckout = checkout
                self.pazeButton = component
                self.isLoading = false
            }
        } catch {
            await MainActor.run {
                self.errorMessage = error.localizedDescription
                self.isLoading = false
            }
        }
    }

    private func createPxpCheckout(session: BackendSession) throws -> PxpCheckout {
        let sessionData = SessionData(
            sessionId: session.sessionId,
            hmacKey: session.hmacKey,
            encryptionKey: session.encryptionKey,
            allowedFundingTypes: AllowedFundingType(
                wallets: Wallets(
                    paze: Paze(
                        clientId: session.pazeClientId,
                        profileId: session.pazeProfileId,
                        merchantCategoryCode: session.merchantCategoryCode
                    )
                )
            )
        )

        let transactionData = TransactionData(
            amount: session.amount,
            currency: "USD",
            entryType: .ecom,
            intent: TransactionIntentData(card: .authorisation),
            merchantTransactionId: session.merchantTransactionId,
            merchantTransactionDate: { Date() }
        )

        let config = CheckoutConfig(
            environment: .test,
            session: sessionData,
            transactionData: transactionData,
            merchantShopperId: "shopper-123",
            ownerId: session.ownerId,
            clientName: "Your Merchant",
            siteName: "Your Store",
            onGetShopper: { async in
                TransactionShopper(
                    id: "shopper-123",
                    firstName: "John",
                    lastName: "Doe",
                    email: "customer@example.com"
                )
            }
        )

        return try PxpCheckout.initialize(config: config)
    }

    private func buildPazeConfig() -> PazeButtonComponentConfig {
        let config = PazeButtonComponentConfig()
        config.emailAddress = "customer@example.com"
        config.style = PazeButtonStyleConfig(color: .auto, shape: .rounded, label: .checkoutWith)

        config.onCheckoutComplete = { _ async in true }

        config.onPostAuthorisation = { result async in
            await verifyPaymentOnBackend(systemTransactionId: result.systemTransactionId)
        }

        config.onSubmitError = { submitError async in
            if let failed = submitError as? FailedSubmitResult {
                print("Authorisation failed:", failed.errorReason ?? "")
            }
        }

        config.onError = { error in
            print("Paze error [\(error.errorCode)]: \(error.errorMessage)")
        }

        return config
    }

    private func fetchSessionFromBackend() async throws -> BackendSession {
        // Replace with your backend API call
        fatalError("Implement session fetch")
    }

    private func verifyPaymentOnBackend(systemTransactionId: String) async {
        // Replace with your verification logic
    }
}