react-native-tpay 0.3.0

package/android/src/main/java/com/tpay/util/TpayUtil.kt

@@ -0,0 +1,67 @@
+package com.tpay.util
+
+import com.tpay.model.*
+import com.tpay.sdk.api.tpayModule.TpayModule
+import com.tpay.sdk.api.providers.*
+import com.tpay.sdk.api.models.*
+import com.tpay.sdk.api.models.merchant.*
+import com.tpay.sdk.api.models.transaction.SingleTransaction
+import com.tpay.model.Configuration
+
+object TpayUtil {
+  private const val EMPTY_MERCHANT_ID = "EMPTY_ID"
+
+  fun configure(configuration: Configuration) {
+    when (configuration) {
+      is TpayConfiguration -> configureStandard(configuration)
+    }
+  }
+
+  private fun configureStandard(configuration: TpayConfiguration) {
+    configuration.run {
+      merchant.walletConfiguration?.googlePay?.run {
+        if (merchantId.isNotBlank()) {
+          TpayModule.configure(GooglePayConfiguration(merchantId))
+        }
+      }
+
+      TpayModule
+        .configure(object : SSLCertificatesProvider {
+          override var apiConfiguration: CertificatePinningConfiguration = CertificatePinningConfiguration(
+            publicKeyHash = merchant.certificateConfiguration.publicKeyHash
+          )
+        })
+        .configure(merchant.environment)
+        .configure(paymentMethods.methods)
+        .configure(languages.preferredLanguage, languages.supportedLanguages)
+        .configure(Compatibility.Flutter)
+        .configure(object : MerchantDetailsProvider {
+          override fun merchantDisplayName(language: Language): String {
+            return merchantDetails.displayNames
+              .first { localization -> localization.language == language }
+              .value
+          }
+
+          override fun merchantCity(language: Language): String? {
+            return merchantDetails.merchantHeadquarters
+              .first { localization -> localization.language == language }
+              .value
+          }
+
+          override fun regulationsLink(language: Language): String {
+            return merchantDetails.regulations
+              .first { localization -> localization.language == language }
+              .value
+          }
+        })
+        .configure(
+          Merchant(
+            authorization = Merchant.Authorization(
+              merchant.authorization.clientId,
+              merchant.authorization.clientSecret
+            )
+          )
+        )
+    }
+  }
+}

package/android/src/main/java/com/tpay/util/ValidationMessages.kt

@@ -0,0 +1,19 @@
+package com.tpay.util
+
+object ValidationMessages {
+  const val AMOUNT_NEGATIVE = "Amount has to be greater than 0"
+  const val DESCRIPTION_BLANK = "Description cannot be blank"
+  const val CARD_TOKEN_BLANK = "Card token cannot be blank"
+  const val BLIK_CODE_AND_ALIAS_NULL = "Please provide BLIK code or alias"
+  const val BLIK_CODE_INVALID = "BLIK code is invalid"
+  const val LONG_POLLING_DELAY_NEGATIVE = "Long polling delay has to be greater than 0"
+  const val LONG_POLLING_MAX_REQUEST_COUNT_NEGATIVE = "Long polling max request count has to be greater than 0"
+  const val NOTIFICATION_EMAIL_INVALID = "Notification email is invalid"
+  const val PAYER_EMAIL_INVALID = "Payer email is invalid"
+  const val CREDIT_CARD_DATA_NULL = "Please provide credit card data or credit card token"
+  const val PROVIDE_LOCALIZATION_MESSAGE = "Provide display names and regulations for all defined languages"
+  const val UNKNOWN_ENVIRONMENT = "Unknown Tpay environment"
+  const val CREDENTIALS_BLANK = "Credentials cannot be blank"
+  const val GOOGLE_PAY_TOKEN_BLANK = "Google Pay token cannot be blank"
+  const val PAYER_REQUIRED_TOKEN_PAYMENT = "Payer's name and email are required for credit card token payment"
+}

package/ios/Source/Configuration/MerchantConfiguration.swift

@@ -0,0 +1,120 @@
+import Security
+import Tpay
+
+final class MerchantConfiguration {
+
+    // MARK: - Properties
+
+    private let configuration: T.MerchantConfiguration
+
+    // MARK: - Initializers
+
+    init?(configuration: String) {
+        guard let configurationData = configuration.data(using: .utf8),
+              let configuration = try? JSONDecoder().decode(T.MerchantConfiguration.self, from: configurationData) else { return nil }
+        self.configuration = configuration
+    }
+
+    // MARK: - API
+
+    func merchant() -> Merchant? {
+        let merchant = configuration.merchant
+        guard let environment = makeEnvironment(from: merchant.environment) else { return nil }
+
+        let cardApi = makeCardApi(from: merchant.certificatePinningConfiguration)
+        let blikConfiguration = makeBlikConfiguration(from: merchant.blikAliasToRegister)
+        let walletConfiguration = makeWalletConfiguration(from: merchant.walletConfiguration?.applePay)
+        return .init(authorization: .init(clientId: merchant.authorization.clientId, clientSecret: merchant.authorization.clientSecret),
+                     cardsConfiguration: cardApi,
+                     environment: environment,
+                     blikConfiguration: blikConfiguration,
+                     walletConfiguration: walletConfiguration)
+    }
+
+    func paymentMethods() -> [PaymentMethod]? {
+        guard let configurationPaymentMethods = configuration.paymentMethods else { return nil }
+
+        let methods = configurationPaymentMethods.methods.compactMap { T.PaymentMethod(rawValue: $0) }.sorted { $0.paymentOrder < $1.paymentOrder }.map { $0.tpayPaymentMethod }
+        let installmentPayments = (configurationPaymentMethods.installmentPayments ?? []).compactMap { T.PaymentMethod(rawValue: $0) }.sorted { $0.paymentOrder < $1.paymentOrder }.map { $0.tpayPaymentMethod }
+        let wallets = (configurationPaymentMethods.wallets ?? []).compactMap { T.PaymentMethod(rawValue: $0) }.sorted { $0.paymentOrder < $1.paymentOrder }.map { $0.tpayPaymentMethod }
+
+        let paymentMethods = (methods + installmentPayments + wallets)
+
+        return paymentMethods.isEmpty ? nil : paymentMethods
+    }
+
+    func preferredLanguage() -> Language? {
+        guard let preferredLanguage = configuration.languages?.preferredLanguage else { return nil }
+        return .init(rawValue: preferredLanguage)
+    }
+
+    func supportedLanguage() -> [Language] {
+        guard let supportedLanguages = configuration.languages?.supportedLanguages else { return [] }
+        return supportedLanguages.compactMap { Language(rawValue: $0) }
+    }
+
+    func detailsProvider() -> DefaultMerchantDetailsProvider {
+        let details = configuration.merchantDetails
+
+        var merchantDisplayName: [Language: String] = [:]
+        if let displayNames = details.merchantDisplayName {
+            displayNames.forEach { detail in
+                if let language = Language(rawValue: detail.language) {
+                    merchantDisplayName[language] = detail.value
+                }
+            }
+        }
+
+        var merchantHeadquarters: [Language: String] = [:]
+        if let headquaters = details.merchantHeadquarters {
+            headquaters.forEach { detail in
+                if let language = Language(rawValue: detail.language) {
+                    merchantHeadquarters[language] = detail.value
+                }
+            }
+        }
+
+        var regulationsLink: [Language: URL] = [:]
+        if let links = details.regulations {
+            links.forEach { detail in
+                if let language = Language(rawValue: detail.language), let url = URL(string: detail.value) {
+                    regulationsLink[language] = url
+                }
+            }
+        }
+
+        return .init(merchantDisplayName: merchantDisplayName, merchantHeadquarters: merchantHeadquarters, regulationsLink: regulationsLink)
+    }
+
+    func sslCertificatesProvider() -> DefaultSSLCertificatesProvider? {
+        guard let publicKeyHash = configuration.merchant.certificatePinningConfiguration?.publicKeyHash else { return nil }
+        return .init(apiConfiguration: .init(publicKeyHashes: [publicKeyHash]))
+    }
+
+    // MARK: - Private
+
+    private func makeCardApi(from certificatePinningConfiguration: T.Merchant.CertificatePinning?) -> Merchant.CardsAPI? {
+        guard let publicKeyHash = certificatePinningConfiguration?.publicKeyHash else { return nil }
+        return try? .init(publicKey: publicKeyHash)
+    }
+
+    private func makeEnvironment(from environment: String) -> Merchant.Environment? {
+        guard let environment = T.Environment(rawValue: environment) else { return nil }
+        return environment.tpayEnvironment
+    }
+
+    private func makeBlikConfiguration(from blikAliasToRegister: String?) -> Merchant.BlikConfiguration? {
+        guard let blikAliasToRegister = blikAliasToRegister else { return nil }
+
+        return .init(aliasToBeRegistered: .init(value: .uid(blikAliasToRegister)))
+    }
+
+    private func makeWalletConfiguration(from applePayConfiguration: T.Merchant.WalletConfiguration.ApplePay?) -> Merchant.WalletConfiguration? {
+        guard let applePayConfiguration = applePayConfiguration,
+              let countryCode = Merchant.WalletConfiguration.ApplePayConfiguration.CountryCode(rawValue: applePayConfiguration.countryCode)
+        else { return nil }
+
+        return .init(applePayConfiguration: .init(merchantIdentifier: applePayConfiguration.merchantIdentifier,
+                                                  countryCode: countryCode))
+    }
+}

package/ios/Source/Configuration/PaymentMethodConfiguration.swift

@@ -0,0 +1,41 @@
+import Tpay
+
+final class PaymentMethodsConfiguration {
+
+    // MARK: - Constants
+
+    enum Constants {
+        static let amount = "amount"
+        static let min = "min"
+        static let max = "max"
+    }
+
+    // MARK: - API
+
+    static func configuration(for paymentChannels: [Headless.Models.PaymentChannel]) -> [T.PaymentChannel] {
+        makePaymentChannelsInfo(from: paymentChannels)
+    }
+
+    // MARK: - Private
+
+    private static func makePaymentChannelsInfo(from paymentChannels: [Headless.Models.PaymentChannel]) -> [T.PaymentChannel] {
+        paymentChannels.map { makeTransportationPaymentChanel(from: $0) }
+    }
+
+    private static func makeTransportationPaymentChanel(from paymentChanel: Headless.Models.PaymentChannel) -> T.PaymentChannel {
+        T.PaymentChannel(id: paymentChanel.id,
+                         name: paymentChanel.fullName,
+                         imageUrl: paymentChanel.imageUrl?.absoluteString,
+                         constraints: makeDomainConstains(from: paymentChanel.constraints ?? []))
+    }
+
+    private static func makeDomainConstains(from constains: [Headless.Models.PaymentChannel.Constraint]) -> [T.PaymentChannel.Constraint] {
+        let amountConstraints = constains.filter { $0.field == Constants.amount }
+        let min = amountConstraints.filter { $0.type == Constants.min }.map { Double($0.value) }.first ?? nil
+        let max = amountConstraints.filter { $0.type == Constants.max }.map { Double($0.value) }.first ?? nil
+        if min == nil, max == nil {
+            return []
+        }
+        return [.init(type: Constants.amount.uppercased(), minimum: min, maximum: max)]
+    }
+}

package/ios/Source/Configuration/TransactionConfiguration.swift

@@ -0,0 +1,200 @@
+import Tpay
+
+final class TransactionConfiguration {
+
+    // MARK: - Constants
+
+    private enum Defaults {
+        static let successRedirectUrl = URL(string: "https://secure.tpay.com/mobile-sdk/success/")!
+        static let errorRedirectUrl = URL(string: "https://secure.tpay.com/mobile-sdk/error/")!
+    }
+
+    // MARK: - API
+
+    static func single(transactionConfiguration: String) -> Transaction? {
+        guard let trancationData = transactionConfiguration.data(using: .utf8),
+              let signleTransaction = try? JSONDecoder().decode(T.SingleTransaction.self, from: trancationData) else {
+            return nil
+        }
+
+        let payerContext = makeTransactionPayerContext(from: signleTransaction)
+
+        return SingleTransaction(amount: signleTransaction.amount, description: signleTransaction.description, payerContext: payerContext)
+    }
+
+    static func cardTokenTransaction(transactionConfiguration: String) -> Transaction? {
+        guard let trancationData = transactionConfiguration.data(using: .utf8),
+              let tokenPayment = try? JSONDecoder().decode(T.TokenPayment.self, from: trancationData) else {
+            return nil
+        }
+        let payerContext = makeTokenPayerContext(from: tokenPayment)
+        return SingleTransaction(amount: tokenPayment.amount, description: tokenPayment.description, payerContext: payerContext)
+    }
+    
+    static func addCard(tokenisationConfiguration: String) -> TokenizationData? {
+        guard let tokenisationData = tokenisationConfiguration.data(using: .utf8),
+              let tokenisation = try? JSONDecoder().decode(T.Tokenisation.self, from: tokenisationData),
+              let payer = makePayer(from: tokenisation.payer)
+        else {
+            return nil
+        }
+        return TokenizationData.init(payer: payer, notificationUrl: tokenisation.notificationUrl, successRedirectUrl: tokenisation.successRedirectUrl, errorRedirectUrl: tokenisation.errorRedirectUrl)
+    }
+
+    static func cardPayment(cardPaymentConfiguration: String, paymentChannels: [Headless.Models.PaymentChannel]) -> CardPayment? {
+        guard let cardPaymentData = cardPaymentConfiguration.data(using: .utf8),
+              let cardPayment = try? JSONDecoder().decode(T.CardPayment.self, from: cardPaymentData),
+              let payer = makePayer(from: cardPayment.payer),
+              let paymentChannel = paymentChannels.first(where: { $0.paymentKind == .card }) else {
+            return nil
+        }
+
+        let callbacks = makeCallbacksConfiguration(from: cardPayment.callbacks)
+
+        let card = cardPayment.creditCard.flatMap { creditCard -> Headless.Models.Card? in
+            Headless.Models.Card(number: creditCard.number, expiryDate: .init(month: creditCard.expiryDate.month, year: creditCard.expiryDate.year), securityCode: creditCard.securityCode, shouldTokenize: creditCard.config.shouldSave)
+        }
+
+        let cardToken = cardPayment.creditCardToken.flatMap { token -> Headless.Models.CardToken? in
+            try? Headless.Models.CardToken(token: token, cardTail: "1234", brand: .other(""))
+        }
+
+        return .init(amount: cardPayment.paymentDetails.amount,
+                     description: cardPayment.paymentDetails.description,
+                     payerContext: .init(payer: payer),
+                     paymentChannel: paymentChannel,
+                     card: card,
+                     cardToken: cardToken,
+                     callbacks: callbacks)
+    }
+
+    static func blikPayment(blikPaymentConfiguration: String, paymentChannels: [Headless.Models.PaymentChannel]) -> BlikPayment? {
+        guard let blikPaymentData = blikPaymentConfiguration.data(using: .utf8),
+              let blikPayment = try? JSONDecoder().decode(T.BlikPayment.self, from: blikPaymentData),
+              let payer = makePayer(from: blikPayment.payer),
+              let paymentChannel = paymentChannels.first(where: { $0.paymentKind == .blik }) else {
+            return nil
+        }
+
+        let callbacks = makeCallbacksConfiguration(from: blikPayment.callbacks)
+
+        return .init(amount: blikPayment.paymentDetails.amount,
+                     description: blikPayment.paymentDetails.description,
+                     payerContext: .init(payer: payer),
+                     token: blikPayment.code,
+                     alias: blikPayment.alias?.value,
+                     paymentChannel: paymentChannel,
+                     callbacks: callbacks)
+    }
+
+    static func bankPayment(bankPaymentConfiguration: String, paymentChannels: [Headless.Models.PaymentChannel]) -> BankPayment? {
+        guard let bankPaymentData = bankPaymentConfiguration.data(using: .utf8),
+              let bankPayment = try? JSONDecoder().decode(T.BankPayment.self, from: bankPaymentData),
+              let payer = makePayer(from: bankPayment.payer),
+              let paymentChannel = paymentChannels.first(where: { $0.paymentKind == .pbl }) else {
+            return nil
+        }
+
+        let callbacks = makeCallbacksConfiguration(from: bankPayment.callbacks)
+
+        return .init(amount: bankPayment.paymentDetails.amount,
+                     description: bankPayment.paymentDetails.description,
+                     payerContext: .init(payer: payer),
+                     paymentChannel: paymentChannel,
+                     callbacks: callbacks)
+    }
+
+    static func digitalWalletPayment(digitalWalletPaymentConfiguration: String, paymentChannels: [Headless.Models.PaymentChannel]) -> DigitalWalletPayment? {
+        guard let digitalWalletPaymentData = digitalWalletPaymentConfiguration.data(using: .utf8),
+              let digitalWalletPayment = try? JSONDecoder().decode(T.DigitalWalletPayment.self, from: digitalWalletPaymentData),
+              let payer = makePayer(from: digitalWalletPayment.payer),
+              let paymentChannel = paymentChannels.first(where: { $0.paymentKind == .applePay }) else {
+            return nil
+        }
+
+        let callbacks = makeCallbacksConfiguration(from: digitalWalletPayment.callbacks)
+
+        return .init(amount: digitalWalletPayment.paymentDetails.amount,
+                     description: digitalWalletPayment.paymentDetails.description,
+                     payerContext: .init(payer: payer),
+                     paymentChannel: paymentChannel,
+                     token: digitalWalletPayment.applePayToken,
+                     callbacks: callbacks)
+    }
+
+    static func continuePayment(continuePaymentConfiguration: String) -> ContinuePayment? {
+        guard let continuePaymentData = continuePaymentConfiguration.data(using: .utf8),
+              let continuePayment = try? JSONDecoder().decode(T.ContinuePayment.self, from: continuePaymentData) else {
+            return nil
+        }
+
+        return .init(id: continuePayment.transactionId, alias: continuePayment.blikAlias.value, ambiguousAlias: continuePayment.ambiguousBlikAlias)
+    }
+
+    static func makeAliases(from aliases: [Headless.Models.Blik.AmbiguousBlikAlias.Application]) -> [T.AmbiguousAlias] {
+        aliases.map { T.AmbiguousAlias(name: $0.name, code: $0.key) }
+    }
+
+    // MARK: - Private
+
+    private static func makeTransactionPayerContext(from signleTransaction: T.SingleTransaction) -> PayerContext? {
+        guard let payerContext = signleTransaction.payerContext else { return nil }
+
+        let payer = makePayer(from: payerContext.payer)
+        let blikAllias = payerContext.automaticPaymentMethods?.blikAlias?.value
+        let registredBlikAlias = blikAllias != nil ? RegisteredBlikAlias(value: .uid(blikAllias!)) : nil
+        let tokenizedCards = payerContext.automaticPaymentMethods?.tokenizedCards?.compactMap { makeCardToken(from: $0) }
+
+        return .init(payer: payer, automaticPaymentMethods: .init(registeredBlikAlias: registredBlikAlias, tokenizedCards: tokenizedCards))
+    }
+
+    private static func makeTokenPayerContext(from tokenPayment: T.TokenPayment) -> PayerContext {
+        let payer = makePayer(from: tokenPayment.payer)
+        let tokenizedCard = makeCardToken(from: tokenPayment)
+
+        return .init(payer: payer, automaticPaymentMethods: .init(tokenizedCards: tokenizedCard != nil ? [tokenizedCard!] : []))
+    }
+
+    private static func makePayer(from contexPayer: T.Payer?) -> Payer? {
+        guard let contexPayer = contexPayer else { return nil }
+
+        let address = makeAddress(from: contexPayer.address)
+
+        return .init(name: contexPayer.name, email: contexPayer.email, phone: contexPayer.phone, address: address)
+    }
+
+    private static func makeAddress(from contextAddress: T.Payer.Address?) -> Address? {
+        guard let contextAddress = contextAddress else { return nil }
+
+        return .init(address: contextAddress.address,
+                     city: contextAddress.city,
+                     country: contextAddress.countryCode,
+                     postalCode: contextAddress.postalCode)
+    }
+
+    private static func makeCardToken(from tokenPayment: T.TokenPayment) -> CardToken? {
+        return try? .init(token: tokenPayment.cardToken, cardTail: "1234", brand: .other(""))
+    }
+
+    private static func makeCardToken(from tokenData: T.CardToken?) -> CardToken? {
+        guard let tokenData = tokenData else { return nil }
+        return try? .init(token: tokenData.token, cardTail: tokenData.cardTail, brand: makeCardBrand(from: tokenData.brand))
+    }
+
+    private static func makeCallbacksConfiguration(from callbacks: T.Callbacks) -> CallbacksConfiguration {
+        return .init(successRedirectUrl: URL(string: callbacks.redirects?.successUrl ?? Defaults.successRedirectUrl.absoluteString) ?? Defaults.successRedirectUrl,
+                     errorRedirectUrl: URL(string: callbacks.redirects?.errorUrl ?? Defaults.errorRedirectUrl.absoluteString) ?? Defaults.errorRedirectUrl,
+                     notificationsUrl: callbacks.notifications.flatMap { URL(string: $0.url) })
+    }
+
+    private static func makeCardBrand(from brand: String) -> CardToken.Brand {
+        switch brand {
+        case "visa":
+            return CardToken.Brand.visa
+        case "mastercard":
+            return CardToken.Brand.mastercard
+        default:
+            return CardToken.Brand.other(brand)
+        }
+    }
+}

package/ios/Source/Extension/TPay+Setup.swift

@@ -0,0 +1,32 @@
+import Tpay
+
+extension TpayModule {
+
+    // MARK: - API
+
+    static func setup(merchant: Merchant,
+                      paymentMethods: [PaymentMethod]?,
+                      preferredLanguage: Language?,
+                      supportedLanguages: [Language],
+                      sslCertificatesProvider: SSLCertificatesProvider?,
+                      detailsProvider: MerchantDetailsProvider) throws {
+        try TpayModule.configure(merchant: merchant)
+            .configure(merchantDetailsProvider: detailsProvider)
+
+        if let preferredLanguage = preferredLanguage {
+            try TpayModule.configure(preferredLanguage: preferredLanguage, supportedLanguages: supportedLanguages)
+        }
+
+        if let paymentMethods = paymentMethods {
+            try TpayModule.configure(paymentMethods: paymentMethods)
+        }
+
+        if let sslCertificatesProvider = sslCertificatesProvider {
+            TpayModule.configure(sslCertificatesProvider: sslCertificatesProvider)
+        }
+
+        if case let .invalid(error) = TpayModule.checkConfiguration() {
+            throw error
+        }
+    }
+}

package/ios/Source/Model/Domain/BankPayment.swift

@@ -0,0 +1,12 @@
+import Tpay
+
+struct BankPayment: Transaction {
+
+    // MARK: - Properties
+
+    let amount: Double
+    let description: String
+    let payerContext: PayerContext?
+    let paymentChannel: Headless.Models.PaymentChannel
+    let callbacks: CallbacksConfiguration
+}

package/ios/Source/Model/Domain/BlikPayment.swift

@@ -0,0 +1,14 @@
+import Tpay
+
+struct BlikPayment: Transaction {
+
+    // MARK: - Properties
+
+    let amount: Double
+    let description: String
+    let payerContext: PayerContext?
+    let token: String?
+    let alias: String?
+    let paymentChannel: Headless.Models.PaymentChannel
+    let callbacks: CallbacksConfiguration
+}

package/ios/Source/Model/Domain/CardPayment.swift

@@ -0,0 +1,14 @@
+import Tpay
+
+struct CardPayment: Transaction {
+
+    // MARK: - Properties
+
+    let amount: Double
+    let description: String
+    let payerContext: PayerContext?
+    let paymentChannel: Headless.Models.PaymentChannel
+    let card: Headless.Models.Card?
+    let cardToken: Headless.Models.CardToken?
+    let callbacks: CallbacksConfiguration
+}

package/ios/Source/Model/Domain/ConfigurationResult.swift

@@ -0,0 +1,98 @@
+import Foundation
+
+struct ConfigurationResult: Encodable {
+
+    // MARK: - Constants
+
+    private enum Constant {
+        static let configurationSuccess = "configurationSuccess"
+        static let configurationFailure = "configurationFailure"
+        static let paymentCompleted = "paymentCompleted"
+        static let paymentCancelled = "paymentCancelled"
+        static let paymentError = "paymentError"
+        static let tokenPaymentCompleted = "tokenPaymentCompleted"
+        static let tokenPaymentCancelled = "tokenPaymentCancelled"
+        static let tokenPaymentError = "tokenPaymentError"
+        static let tokenizationCompleted = "tokenizationCompleted"
+        static let tokenizationCancelled = "tokenizationCancelled"
+        static let unknownHandleMethod = "unknownHandleMethod"
+    }
+
+    // MARK: - Properties
+
+    let type: String
+    let message: String?
+
+    // MARK: - Results
+
+    static func configurationValid() -> ConfigurationResult {
+        return .init(type: Constant.configurationSuccess, message: nil)
+    }
+
+    static func configurationFailure() -> ConfigurationResult {
+        return .init(type: Constant.configurationFailure, message: nil)
+    }
+
+    static func configurationFailure(error: Error) -> ConfigurationResult {
+        return .errorResult(type: Constant.configurationFailure, error: error)
+    }
+
+    static func paymentCompleted(transactionId: String) -> ConfigurationResult {
+        return .init(type: Constant.paymentCompleted, message: transactionId)
+    }
+
+    static func paymentCancelled(transactionId: String) -> ConfigurationResult {
+        return .init(type: Constant.paymentCancelled, message: transactionId)
+    }
+
+    static func payment(error: Error) -> ConfigurationResult {
+        return .errorResult(type: Constant.paymentError, error: error)
+    }
+
+    static func tokenPaymentCompleted(transactionId: String) -> ConfigurationResult {
+        return .init(type: Constant.tokenPaymentCompleted, message: transactionId)
+    }
+
+    static func tokenPaymentCancelled(transactionId: String) -> ConfigurationResult {
+        return .init(type: Constant.tokenPaymentCancelled, message: transactionId)
+    }
+
+    static func tokenPayment(error: Error) -> ConfigurationResult {
+        return .errorResult(type: Constant.tokenPaymentError, error: error)
+    }
+
+    static func tokenizationCompleted() -> ConfigurationResult {
+        return .init(type: Constant.tokenizationCompleted, message: nil)
+    }
+
+    static func tokenizationCancelled() -> ConfigurationResult {
+        return .init(type: Constant.tokenizationCancelled, message: nil)
+    }
+
+    static func unknownHandleMethod() -> ConfigurationResult {
+        return .init(type: Constant.unknownHandleMethod, message: nil)
+    }
+
+    // MARK: - Private
+
+    private static func errorResult(type: String, error: Error) -> ConfigurationResult {
+        .init(type: type, message: "\(error)")
+    }
+}
+
+// MARK: - Extensions
+
+extension ConfigurationResult {
+
+    func toJson() -> String {
+        do {
+            let jsonData = try JSONEncoder().encode(self)
+            if let jsonString = String(data: jsonData, encoding: .utf8) {
+                return jsonString
+            }
+        } catch {
+            debugPrint("Error converting ConfigurationResult to JSON: \(error)")
+        }
+        return ""
+    }
+}

package/ios/Source/Model/Domain/ContinuePayment.swift

@@ -0,0 +1,10 @@
+import Tpay
+
+struct ContinuePayment {
+
+    // MARK: - Properties
+
+    let id: String
+    let alias: String
+    let ambiguousAlias: T.AmbiguousAlias
+}

package/ios/Source/Model/Domain/DigitalWalletPayment.swift

@@ -0,0 +1,13 @@
+import Tpay
+
+struct DigitalWalletPayment: Transaction {
+
+    // MARK: - Properties
+
+    let amount: Double
+    let description: String
+    let payerContext: PayerContext?
+    let paymentChannel: Headless.Models.PaymentChannel
+    let token: String
+    let callbacks: CallbacksConfiguration
+}