Detalles del caso de uso híbrido

Al enviar eventos móviles fuera de la aplicación o datos de eventos web desde su servidor a Singular, es esencial incluir el identificador correspondiente desde Singular Mobile SDK o Web SDK. Esto garantiza que la actividad del evento se atribuya con precisión al dispositivo correcto.

Flujo de datos

Existen dos métodos principales para recuperar estos datos del dispositivo:

1. Flujo de datos gestionado por el cliente: Esta opción consiste en capturar todos los puntos de datos necesarios en el cliente y pasarlos a su servidor a través de su propia API. Este enfoque le permite recopilar identificadores de dispositivos, datos de eventos y otros atributos necesarios directamente desde el lado del cliente (por ejemplo, aplicación móvil o sitio web) y reenviarlos a su servidor, donde puede procesarlos y enviarlos a Singular utilizando la API EVENT de servidor a servidor.
2. Postback: Esta opción consiste en configurar el postback de BI interno de Singular, que permite a Singular enviar un postback a su endpoint designado con una carga útil JSON. Este postback se envía en tiempo real después de que se produzca una instalación, un reenganche y/o un evento dentro de la aplicación. El payload incluirá todos los puntos de datos necesarios para enviar con éxito eventos del lado del servidor fuera de la aplicación. Para obtener instrucciones detalladas sobre cómo configurar el postback de BI interno, haga clic[AQUÍ].

Ambas opciones pueden requerir cierta lógica del lado del servidor para mantener un gráfico del dispositivo. Si Singular SDK detecta un cambio en el identificador del dispositivo, es fundamental que su servidor se actualice en consecuencia para garantizar un seguimiento y una atribución precisos.

Para implementar la primera opción, en la que se capturan los identificadores de dispositivo y los parámetros de la aplicación y se envían al servidor para su uso con los puntos finales de la API de Singular, consulte los siguientes artículos:

• Revise los parámetros requeridos del punto final de eventos.
• Revise la Guía de recuperación de datos de dispositivos de servidor a servidor para ejemplos de código de iOS y Android para ayudar con la recuperación de identificadores de dispositivos específicos y puntos de datos de dispositivos.

Revise las directrices generales a continuación para seguir las directrices generales de una configuración de Servidor a Servidor. Con un caso de uso híbrido, puede omitir el punto final SESSION, ya que Singular SDK lo gestionará por usted.

Atribución para campañas de anuncios de búsqueda de Apple (iOS)

Apple Search Ads se considera una red de autoatribución (SAN). A partir de iOS 14.3, la integración de Apple Search Ads es compatible con dos frameworks de iOS:

• Para iOS 14.2 e inferiores, Apple Search Ads es compatible a través del framework iAd.
• Para iOS 14.3 y posteriores, Apple Search Ads es compatible a través del framework AdServices.
  

Recomendamos que se implementen tanto el marco iAd como el AdServices hasta que el marco iAd quede obsoleto en el futuro. Dado que AdServices es todavía un nuevo servicio de Apple, Singular utilizará ambos servicios pero dará prioridad a AdServices sobre las señales de iAd para la atribución y la generación de informes.

Para más información, consulte nuestra documentación sobre la integración de Apple Search Ads.

Implementación de los anuncios de búsqueda de Apple a través de iAd (iOS 14.2 y versiones inferiores)

1. Recuperación de los datos de atribución:

Para recuperar los datos de atribución, utilice la API de iAd de Apple Search Ads. Llamando a requestAttributionDetails(_:): devuelve un objeto JSON que contiene los datos de atribución.

Por ejemplo

#import <iAd/iAd.h>
  
    Class ADClientClass = NSClassFromString(@"ADClient");
  
    if (ADClientClass) {
        id sharedClient = [ADClientClass performSelector:@selector(sharedClient)];
        
        if ([sharedClient respondsToSelector:@selector(requestAttributionDetailsWithBlock:)]) {
            [sharedClient requestAttributionDetailsWithBlock:^(NSDictionary *attributionDetails, NSError *error) {
                if (attributionDetails && attributionDetails.count > 0) {
                    // REPORT attributionDetails FROM YOUR APP TO YOUR SERVER


                }
            }];
        }
    }

2. Envío de los datos de atribución a Singular:

Para compartir los datos de atribución con Singular, utilice el punto final de notificación de eventos para informar de un evento con el nombre de evento reservado __iAd_Attribution__. Pase el objeto JSON que recuperó en el paso anterior como valor del parámetro e , como en el ejemplo siguiente.

import requests
  import json
  
  SDK_KEY = '[sdk_key from Developer tools > SDK Integration > SDK keys]'
  EVENT_URL = 'https://s2s.singular.net/api/v1/evt'
  
  # !!! REPLACE WITH COLLECTED VALUE FROM APP !!!
  apple_attribution_data = {
    u'Version3.1': {
        u'iad-adgroup-id': u'1234567',
        u'iad-adgroup-name': u'Ad Group Name',
        u'iad-attribution': u'true',
        u'iad-campaign-id': u'1234567',
        u'iad-campaign-name': u'Search Campaign',
        u'iad-click-date': u'2016-05-21T12:19:31Z',
        u'iad-conversion-date': u'2016-05-21T12:19:41Z',
        u'iad-keyword': u'ballon',
        u'iad-lineitem-id': u'1234567',
        u'iad-lineitem-name': u'Line Item Name',
        u'iad-org-name': u'Cool Company',
        u'iad-purchase-date': u'2016-05-21T12:19:41Z'
    }
  }
  
  params = {
    'n': '__iAd_Attribution__',
    'e': json.dumps(apple_attribution_data),
    'a': SDK_KEY,
    'p': 'iOS',
    'i': 'com.singular.app',
    'ip': '10.1.2.3',
    've': '9.2',
    'mo': 'iPhone9%2C4',
    'lc': 'en_US',
    'idfa': '8ECD7512-2864-440C-93F3-A3CABE62525B',
    'idfv': '38548D9F-3F73-4D4B-8545-9A920CC89191',
    'utime': 1483228800
  }
  
  result = requests.get(EVENT_URL, params=params)
  print result.json()

https://s2s.singular.net/api/v1/evt?n=__iAd_Attribution__&e=%7B%22Version3.1%22%3A%7B%22iad-purchase-date%22%3A%20%222016-10-25T22%3A24%3A35Z%22%2C%22iad-keyword%22%3A%20%22ballon%22%2C%22iad-adgroup-id%22%3A%20%221234567%22%2C%22iad-campaign-id%22%3A%20%221234567%22%2C%22iad-lineitem-id%22%3A%20%221234567%22%2C%22iad-org-id%22%3A%20%224070%22%2C%22iad-org-name%22%3A%20%22Cool%20Company%22%2C%22iad-campaign-name%22%3A%20%22Search%20Campaign%22%2C%22iad-conversion-date%22%3A%20%222016-05-21T12%3A19%3A41Z%22%2C%22iad-conversion-type%22%3A%20%22Redownload%22%2C%22iad-click-date%22%3A%20%222016-05-21T12%3A19%3A31Z%22%2C%22iad-attribution%22%3A%20%22true%22%2C%22iad-adgroup-name%22%3A%20%22Ad%20Group%20Name%22%2C%22iad-lineitem-name%22%3A%20%22Line%20Item%20Name%22%7D%7D&a=SDK_KEY&p=iOS&i=com.singular.app&ip=10.1.2.3&ve=9.2&ma=Apple&mo=iPhone8%2C1&lc=en_US&idfa=8ECD7512-2864-440C-93F3-A3CABE62525B&idfv=38548D9F-3F73-4D4B-8545-9A920CC89191&utime=1568948680

Implementación de los anuncios de búsqueda de Apple a través de AdServices (iOS 14.3 y versiones posteriores)

1. Recuperación del token de atribución:

Recupere el token de atribución mediante attributionToken() en cuanto la aplicación se inicialice por primera vez tras una instalación o reinstalación.

Por ejemplo:

#import <AdServices/AdServices.h> 

NSError *error = nil;
Class AAAttributionClass = NSClassFromString(@"AAAttribution");
if (AAAttributionClass) {
    NSString *attributionToken = [AAAttributionClass attributionTokenWithError:&error];
    if (!error && attributionToken) {
        // Handle attributionToken


    }
}

Notas:

2. Envíe el código de atribución a Singular:

Codifique la URL del token y envíelo a Singular a través del endpoint de notificación de sesión, anexado al parámetro &attribution_token=. Este token debe enviarse en la primera sesión después de cada instalación y reinstalación para que Singular pueda realizar un seguimiento de las descargas y re-descargas de Apple Search Ads.

Importante: Envío del referente de instalación de Google Play (Android)

El referente de instalación contiene información sobre quién envió a un usuario a Google Play Store. Cuando el referente de instalación está disponible para Singular, proporciona la forma más precisa de atribuir instalaciones. Recupere este valor y páselo a Singular en la primera llamada de notificación de sesión. Es necesario para algunas funciones importantes de Singular, como recibir datos de Facebook en nuestras exportaciones a nivel de usuario, compartirlos con destinos de datos y enviar postbacks.

Google Play recopila información de referencia cuando un usuario llega a la tienda. Si el usuario instala más tarde la aplicación a la que fue dirigido, Google Play pone la información a disposición de la aplicación. Para obtener más información, consulte la documentación para desarrolladores de Google.

Para compartir la referencia de instalación con Singular:

1. Cuando la aplicación se abre por primera vez, recupere la referencia de instalación utilizando la API de referencia de instalación de Play.

2. Informe de una sesión a Singular utilizando el punto final de Notificación de Sesión incluyendo el parámetro install_ref. Este parámetro está codificado en JSON y tiene los siguientes atributos:

   Atributo	Descripción
   referrer	El valor de referencia obtenido de la API de referencia de instalación de Play. Se trata de un objeto JSON, así que asegúrese de codificarlo como cadena.
   referrer_source	Especifique "service".
   clickTimestampSeconds	La marca de tiempo de clic recibida de la API de referencias de instalación de Play (por ejemplo, "1550420123").
   installBeginTimestampSeconds	La hora a la que comenzó la instalación, tal y como se recibió de la Play Install Referrer API.
   current_device_time	La hora en el dispositivo actual, en milisegundos (por ejemplo, "1550420454906").

A continuación se muestra un ejemplo de código para informar del evento de referencia de instalación:

import requests
  import json
  
  SDK_KEY = '[sdk_key from Developer tools > SDK Integration > SDK keys]'
  LAUNCH_URL = 'https://s2s.singular.net/api/v1/launch'
  
  referrer_values = {
        "referrer": "tracking_id%3D123456789&utm_source%3Dmdotm%26utm_medium%3Dbanner%26utm_campaign%3Dcampaign",
        "referrer_source" : "service",
        "clickTimestampSeconds" : 1550420123,
        "installBeginTimestampSeconds" : 1550420123,
        "current_device_time" : 1550420454906
      }

referrer_values = json.dumps(referrer_values, separators=(',',':'))
  
   params = {
       'a': SDK_KEY,
       'p': 'Android',
       'i': 'com.singular.app',
       'ip': '10.1.2.3',
       've': '9.2',
       'ma': 'samsung',
       'mo': 'SM-G935F',
       'lc': 'en_US',
       'aifa': '8ecd7512-2864-440c-93f3-a3cabe62525b',
       'andi': 'fc8d449516de0dfb',
       'utime': 1483228800,
       'dnt': 0,
       'install':'true',
       'n': 'MyCoolApp',
       'c': 'wifi',
       'cn': 'Comcast',
       'bd': 'Build/13D15',
       'fcm':'bk3RNwTe3H0CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1',
       'app_v':'1.2.3',
       'openuri':'myapp%3A%2F%2Fhome%2Fpage%3Fqueryparam1%3Dvalue1',
       'ddl_enabled':'false',
       'install_source': 'com.android.vending',
       'install_time': 1510040127,
       'update_time': 1510090877,
      'custom_user_id': '123456789abcd',
      'install_ref' : referrer_values
   }
  
   result = requests.get(LAUNCH_URL, params=params)
   print result.json()

https://s2s.singular.net/api/v1/launch?aifa=8ecd7512-2864-440c-93f3-a3cabe62525b&andi=fc8d449516de0dfb&p=Android&a=SDK_KEY&i=com.singular.app&ip=10.1.2.3&ve=9.2&dnt=0&n=MyCoolApp&dnt=0&c=wifi&cn=Comcast&lc=en_US&bd=Build%2FMMB29K&ma=samsung&mo=SM-G935F&custom_user_id=123456789abcd&install_ref=%7B%22installBeginTimestampSeconds%22%3A%221568939453%22%2C%22referrer%22%3A%22utm_source%3Dgoogle-play%26utm_medium%3Dorganic%22%2C%22clickTimestampSeconds%22%3A%220%22%2C%22referrer_source%22%3A%22service%22%2C%22current_device_time%22%3A%221568944524%22%7D%0A

Meta Install Referrer Attribution (Android)

"Meta Referrer" es una solución de medición específica de Android introducida por Facebook para permitir a los anunciantes acceder a datos de atribución detallados a nivel de usuario para las instalaciones de aplicaciones de Android (consulta las políticas de datos de Facebook). Consiste en implementar las tecnologías "Google Play Install Referrer" (ver "Pasar Google Install Referrer") y "Meta Install Referrer" para la medición de instalaciones de aplicaciones. Más información sobre Meta Referrer en las preguntas frecuentes sobre el tema.

Para compartir la información de Meta Install Referrer con Singnular:

1. Cuando la aplicación se abre por primera vez, recupere el Meta Install Referrer de acuerdo con la documentación de Meta.

2. Reporta una sesión a Singular usando el endpoint Session Notification incluyendo el parámetro meta_ref. Este parámetro está codificado en JSON y tiene los siguientes atributos:

   Atributo	Descripción
   is_ct	El "is_ct" tal y como se recibió de la Meta Install Referrer. (por ejemplo, 0 o 1)
   install_referrer	El "install_referrer" recibido del Meta Install Referrer.
   actual_timestamp	El "actual_timestamp" recibido del Meta Install Referrer (por ejemplo, 1693978124).

Activación de la vinculación profunda

Requisitos previos para la vinculación profunda

La aplicación cliente debe estar configurada para reconocer el Singular Link como un iOS Universal Link o un Android App Link. Siga la guía Prerrequisitos de Singular Links para habilitar el deeplinking de iOS y Android.

Implementación de enlaces profundos

Cuando la aplicación se abre a través de un enlace profundo, capture y añada la openURL a la solicitud de notificación de sesión enviada a Singular añadiendo el valor de la URL al parámetro openuri. Esto es necesario cuando se utilizan enlaces Singular.

El código de la aplicación cliente debe actualizarse para analizar y gestionar los parámetros de enlace profundo de la URL de Singular Links. En el caso de un enlace profundo correcto provocado por un Singular Link, los siguientes parámetros pueden estar presentes en la openURL:

_dl, _ios_dl, _android_dl, _p

• _ios_dl y _android_dl estarán presentes en un enlace cuando el enlace se haya generado para realizar un enlace profundo tanto en iOS COMO en Android con valores de enlace profundo diferentes para cada plataforma.
• Si los valores de enlace profundo son los mismos para iOS Y Android, sólo estará presente _dl.
• Si se pasan datos adicionales en el parámetro passthrough, _p estará presente.

Ejemplo de código Deep Link Handler

La aplicación debe tener un código manejador capaz de analizar el openURL y manejarlo apropiadamente. El siguiente ejemplo muestra cómo podría analizar los parámetros Singular Link.

class DeepLinkHandler {
  func handleURL(_ url: URL) {
    guard let components = URLComponents(url: url, resolvingAgainstBaseURL: true) else {
      return
    }

    var params: [String: String] = [:]

    // Parse query parameters


    if let queryItems = components.queryItems {
      for item in queryItems {
        switch item.name {
        case "_dl":
          params["deeplink"] = item.value
        case "_ios_dl":
          params["ios_deeplink"] = item.value
        case "_p":
          params["passthrough"] = item.value
        default:
          break
        }
      }
    }

    // Handle the parsed parameters


    processDeepLinkParameters(params)
  }

  private func processDeepLinkParameters(_ params: [String: String]) {
    // Process the parameters as needed


    print("Processed parameters: \(params)")
  }
}

// In SceneDelegate or AppDelegate


func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
  guard let url = URLContexts.first?.url else { return }
  let handler = DeepLinkHandler()
  handler.handleURL(url)
}

class DeepLinkHandler {
    fun handleDeepLink(intent: Intent) {
        val data: Uri? = intent.data

        data?.let { uri ->
            val params = mutableMapOf<String, String>()

            // Parse query parameters


            uri.queryParameterNames?.forEach { name ->
                when (name) {
                    "_dl" -> params["deeplink"] = uri.getQueryParameter(name) ?: ""
                    "_android_dl" -> params["android_deeplink"] = uri.getQueryParameter(name) ?: ""
                    "_p" -> params["passthrough"] = uri.getQueryParameter(name) ?: ""
                }
            }

            processDeepLinkParameters(params)
        }
    }

    private fun processDeepLinkParameters(params: Map<String, String>) {
        // Process the parameters as needed


        println("Processed parameters: $params")
    }
}

// In your Activity


class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // Handle deep link if activity was launched from a deep link


        intent?.let { DeepLinkHandler().handleDeepLink(it) }
    }

    override fun onNewIntent(intent: Intent?) {
        super.onNewIntent(intent)
        // Handle deep link if app was already running


        intent?.let { DeepLinkHandler().handleDeepLink(it) }
    }
}

Soporte de enlaces profundos diferidos

Cuando la aplicación se abre por primera vez desde la instalación, active el flujo de enlaces profundos diferidos añadiendo los siguientes parámetros cuando informe de la sesión a Singular:

• install=true
• ddl_enabled=true

Singular comprueba si la aplicación se instaló a través de un enlace de seguimiento que incluía un enlace profundo diferido. Si es así, la petición Session devuelve los siguientes valores en la respuesta a su servidor:

• deferred_deeplink - la dirección del enlace profundo. Esto es lo que debe analizar para mostrar a los usuarios el producto o la experiencia adecuados.
• deferred_passthrough - cualquier parámetro passthrough añadido al enlace profundo.

La aplicación cliente debe incluir código para gestionar el enlace profundo diferido y los parámetros passthrough proporcionados en la respuesta de Singular SESSION API y gestionar los datos adecuadamente. La respuesta JSON de la notificación de SESSION con un valor de enlace profundo diferido tendrá el siguiente aspecto:

{
 "deferred_deeplink":"myapp://deferred-deeplink",
 "status":"ok",
 "deferred_passthrough":"passthroughvalue"
}

Uso de parámetros de passthrough dinámicos

Los enlaces de seguimiento de Singular pueden incluir parámetros de traspaso dinámicos(más información). Si su organización ha configurado parámetros passthrough dinámicos para un enlace, la URL del enlace profundo incluye el parámetro _p seguido de un valor de cadena JSON codificado en la URL o una cadena no estructurada que puede utilizar para mostrar al usuario el contenido o la experiencia adecuados.

Resolución de enlaces cortos

Cuando la aplicación se abre desde un enlace Singular acortado, el siguiente parámetro debe incluirse en la solicitud de lanzamiento para notificar al punto final de Singular Session que la openURL enviada en el parámetro openuri debe resolverse en el enlace Singular largo.

• singular_link_resolve_required=true

Singular devolverá el enlace largo no acortado y el desarrollador de la aplicación puede analizar los parámetros de enlace profundo y passthrough en el gestor de enlaces, como se ha indicado anteriormente.

Ejemplo de respuesta

{
   "status":"ok",
   "resolved_singular_link":"https://myapp.sng.link/A59c0/nha7?_dl=myapp%3A%2F%2Fdeeplink&_ddl=myapp%3A%2F%2Fdeferred-deeplink&_p=passthroughvalue"
}

Ejemplo de evento de ingresos personalizado

import requests

params = {
    "a": "sdk_key_here",
    "p": "Android",
    "i": "com.singular.app",
    "ip": "10.1.2.3",
    "ve": "9.2",
    "aifa": "8ecd7512-2864-440c-93f3-a3cabe62525b",
    "asid": "edee92a2-7b2f-45f4-a509-840f170fc6d9",
    "n": "RevenueEventName",
    "amt": "2.50",
    "cur": "USD",
    "is_revenue_event": "true",
    "purchase_receipt": {
        'orderId"': "GPA.1234",
        "packageName": "com.example",
        "productId": "com.example.product",
        "purchaseTime": 1417113074914,
        "purchaseState": 0,
        "purchaseToken": "hakfcimbkargpM",
    },
    "receipt_signature": "TyVJfHg8OAoW7W4wuJtasr5agEDMnNXvhfrw==",
    "purchase_product_id": "com.example.product",
    "purchase_transaction_id": "GPA.1234-1234-1234-12345",
}

response = requests.get("https://s2s.singular.net/api/v1/evt", params=params)
print(response.json())

GET /api/v1/evt
    ?a=sdk_key_here
    &p=Android
    &i=com.singular.app
    &ip=10.1.2.3
    &ve=9.2
    &aifa=8ecd7512-2864-440c-93f3-a3cabe62525b
    &asid=edee92a2-7b2f-45f4-a509-840f170fc6d9
    &n=RevenueEventName
    &amt=2.50
    &cur=USD
    &is_revenue_event=true
    &purchase_receipt={"orderId":"GPA.1234","packageName":"com.example","productId":"com.example.product","purchaseTime":1417113074914,"purchaseState":0,"purchaseToken":"hakfcimbkargpM"}
    &receipt_signature=TyVJfHg8OAoW7W4wuJtasr5agEDMnNXvhfrw==
    &purchase_product_id=com.example.product
    &purchase_transaction_id=GPA.1234-1234-1234-12345 HTTP/1.1
Host: s2s.singular.net
Accept: application/json

curl -G "https://s2s.singular.net/api/v1/evt" \
  --data-urlencode "a=sdk_key_here" \
  --data-urlencode "p=Android" \
  --data-urlencode "i=com.singular.app" \
  --data-urlencode "ip=10.1.2.3" \
  --data-urlencode "ve=9.2" \
  --data-urlencode "aifa=8ecd7512-2864-440c-93f3-a3cabe62525b" \
  --data-urlencode "asid=edee92a2-7b2f-45f4-a509-840f170fc6d9" \
  --data-urlencode "n=RevenueEventName" \
  --data-urlencode "amt=2.50" \
  --data-urlencode "cur=USD" \
  --data-urlencode "is_revenue_event=true" \
  --data-urlencode "purchase_receipt={\"orderId\":\"GPA.1234\",\"packageName\":\"com.example\",\"productId\":\"com.example.product\",\"purchaseTime\":1417113074914,\"purchaseState\":0,\"purchaseToken\":\"hakfcimbkargpM\"}" \
  --data-urlencode "receipt_signature=TyVJfHg8OAoW7W4wuJtasr5agEDMnNXvhfrw==" \
  --data-urlencode "purchase_product_id=com.example.product" \
  --data-urlencode "purchase_transaction_id=GPA.1234-1234-1234-12345"

Para recuperar este valor, añada el siguiente código a su aplicación:

// ReceiptManager.h


@interface ReceiptManager : NSObject
+ (nullable NSString *)getInstallReceipt;
@end

// ReceiptManager.m


#import <StoreKit/StoreKit.h>

@implementation ReceiptManager

+ (nullable NSString *)getInstallReceipt {
    if (@available(iOS 18.0, *)) {
        dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
        __block NSString *result = nil;
        
        [SKPaymentQueue.defaultQueue addTransactionObserver:[[SKPaymentTransactionObserver alloc] init]];
        
        if (@available(iOS 18.0, *)) {
            [AppTransaction.shared fetchWithCompletionHandler:^(AppTransaction *transaction, NSError *error) {
                if (error) {
                    NSLog(@"Failed to get app transaction: %@", error.localizedDescription);
                } else {
                    result = transaction.jwsRepresentation;
                }
                dispatch_semaphore_signal(semaphore);
            }];
        }
        
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        return result;
        
    } else {
        NSURL *receiptURL = [[NSBundle mainBundle] appStoreReceiptURL];
        if (!receiptURL) {
            NSLog(@"Receipt URL not found");
            return nil;
        }
        
        NSError *error = nil;
        NSData *receiptData = [NSData dataWithContentsOfURL:receiptURL 
                                                   options:NSDataReadingUncached 
                                                     error:&error];
        
        if (error) {
            NSLog(@"Failed to read receipt: %@", error.localizedDescription);
            return nil;
        }
        
        return [receiptData base64EncodedStringWithOptions:0];
    }
}

@end

import Foundation
import StoreKit

class ReceiptManager {
    static func getInstallReceipt() -> String? {
        if #available(iOS 18.0, *) {
            // Synchronous wrapper for async code


            let semaphore = DispatchSemaphore(value: 0)
            var result: String?
            
            Task {
                do {
                    let transaction = try await AppTransaction.shared
                    result = transaction.jwsRepresentation
                    semaphore.signal()
                } catch {
                    debugPrint("Failed to get app transaction: \(error.localizedDescription)")
                    semaphore.signal()
                }
            }
            
            semaphore.wait()
            return result
            
        } else {
            // Legacy receipt fetching


            guard let receiptURL = Bundle.main.appStoreReceiptURL else {
                debugPrint("Receipt URL not found")
                return nil
            }
            
            do {
                let receiptData = try Data(contentsOf: receiptURL, options: .uncached)
                return receiptData.base64EncodedString(options: [])
            } catch {
                debugPrint("Failed to read receipt: \(error.localizedDescription)")
                return nil
            }
        }
    }
}