iOS SDK

Add the package #

The SDK resolves from a private GitHub repository, so Xcode needs a credential before it can fetch anything. Moov supplies a dedicated GitHub account for your team.

1. Sign in to the GitHub account Moov gave you and create a personal access token with read access to repository contents.

2. Add that account to Xcode under Settings → Accounts, using the token as the password.

3. Open File → Add Package Dependencies and enter the package URL:

   https://github.com/moov-sdk/moov-money-ios.git
   

   Set the dependency rule to Up to Next Minor Version. The SDK is pre-1.0, so minor versions can contain breaking changes. Pinning to the minor keeps an upgrade a deliberate act.

4. Add the MoovMoney library to your app target.

If you resolve packages from a Package.swift instead:

dependencies: [
    .package(
        url: "https://github.com/moov-sdk/moov-money-ios.git",
        .upToNextMinor(from: "0.1.0")
    ),
]

Adding the MoovMoney library to your target embeds and signs everything the SDK needs into your app bundle. There’s nothing further to configure.

On CI, Xcode’s account store doesn’t exist, so supply the credential one of two ways. Use the same token through a git credential helper, which works with the https:// URL above:

git config --global credential.helper store
printf 'https://x-access-token:%[email protected]\n' "$GITHUB_TOKEN" > ~/.git-credentials

Or use an SSH deploy key. Change the package URL to [email protected]:moov-sdk/moov-money-ios.git and pass -scmProvider system to xcodebuild so it uses the system git and your SSH agent rather than its own client.

Add usage descriptions #

The SDK needs three usage description strings in your app’s Info.plist. Without the first, the SDK won’t launch. Without the third, your App Store upload is rejected.

<key>NSFaceIDUsageDescription</key>
<string>Confirm it's you before sending a payment.</string>

<key>NSContactsUsageDescription</key>
<string>Find friends and family in your address book to pay.</string>

<key>NSCameraUsageDescription</key>
<string>Take a new profile photo.</string>

NSFaceIDUsageDescription lets the SDK confirm the device owner’s presence before submitting a payment. iOS terminates apps that reach LocalAuthentication without this key, so the SDK refuses to launch instead of crashing your app. You’ll see this as the missingEntitlement case in the next step.

NSContactsUsageDescription lets the SDK offer the device address book when the user chooses a recipient.

NSCameraUsageDescription is required even if you never show a camera interface. The SDK’s binary references AVCaptureDevice, and Apple’s static scan rejects the upload with ITMS-90683 when the string is absent. There’s no way to opt out of this one.

Check availability #

Consult MoovMoneySDK.availability before you offer your entry point. This is part of the integration contract rather than an optimization: it’s what lets you route to a web fallback instead of showing a button that can’t work.

import MoovMoney
import SwiftUI

struct SendMoneyButton: View {
    let configuration: MoovMoneyConfiguration
    let accessToken: String

    @State private var availability: MoovMoneyAvailability?
    @State private var isPresented = false

    var body: some View {
        Button("Send money") {
            if case .unavailable = availability {
                showWebFallback()
            } else {
                isPresented = true
            }
        }
        .onAppear { availability = MoovMoneySDK.availability }
        .moovMoney(
            isPresented: $isPresented,
            accessToken: accessToken,
            configuration: configuration
        )
    }

    private func showWebFallback() { /* your existing web experience */ }
}

Read the verdict once and hold it, as above. Every .unavailable evaluation emits a diagnostic log line with no deduplication, so calling it from inside a SwiftUI body re-emits on every view update.

To tell the reasons apart, for example to distinguish an integration mistake from an old device:

if case .unavailable(let reason) = MoovMoneySDK.availability {
    switch reason {
    case .unsupportedOSVersion(let required):
        // The device is below the minimum iOS version, carried in `required`.
        // Offer your web experience.
        break
    case .missingEntitlement(let key):
        // Your Info.plist is missing `key`. See the previous step.
        break
    case .configurationInvalid(let detail):
        // `detail` names what is wrong with the configuration.
        break
    @unknown default:
        // Treat an unrecognized reason as unavailable and fall back.
        break
    }
}

availability is advisory. Both presentation entry points enforce the same checks independently, so a launch that shouldn’t happen presents nothing and logs it, rather than showing a broken experience.

Build a configuration #

Every field has a default, so the smallest usable configuration is empty. The SDK fetches the signed-in user’s eligible funding methods itself, scoped from the access token: the ones you registered against the participant. There’s nothing for you to resolve and pass in.

let configuration = MoovMoneyConfiguration()

To brand the experience and receive the SDK’s logs:

let configuration = MoovMoneyConfiguration(
    colors: MoovMoneyColors(primary: myBrandColor),
    logger: MoovMoneyLogger { entry in
        myLogger.log("[\(entry.category)] \(entry.message)")
    }
)

Wire up the logger. The SDK reports no outcome to your code, so these lines are the only signal your integration gets, including when the SDK refuses to launch. See Diagnostics below.

Present the experience #

You pass the access token on each presentation rather than storing it in the configuration, so the SDK always runs against a freshly minted credential. It’s a short-lived OAuth bearer token from your own token exchange, and it’s opaque to the SDK, never decoded on device. Your session model stays the authority on who can send or request. See sender authentication for how to mint it.

Button("Send money") { isPresented = true }
    .moovMoney(
        isPresented: $isPresented,
        accessToken: accessToken,
        configuration: configuration
    )

import MoovMoney

@IBAction func sendMoneyTapped() {
    Task {
        guard let accessToken = try? await myBackend.fetchMoovAccessToken() else {
            return showTokenError()
        }
        MoovMoneySDK.present(
            from: self,
            accessToken: accessToken,
            configuration: configuration
        )
    }
}