react-native-pos-pagseguro 1.0.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2025 CECSMH
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/PosPagseguro.podspec

@@ -0,0 +1,29 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "PosPagseguro"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/CECSMH/react-native-pos-pagseguro.git", :tag => "#{s.version}" }
+
+  s.source_files = [
+    "ios/**/*.{swift}",
+    "ios/**/*.{m,mm}",
+    "cpp/**/*.{hpp,cpp}",
+  ]
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+
+  load 'nitrogen/generated/ios/PosPagseguro+autolinking.rb'
+  add_nitrogen_files(s)
+
+  install_modules_dependencies(s)
+end

package/README.md

@@ -0,0 +1,193 @@
+# react-native-pos-pagseguro
+
+**PagSeguro POS SDK for React Native** – Integration with PagSeguro terminals (Moderninha, Moderninha2, etc.) using react-native-nitro-modules.
+
+Supports credit, debit, voucher, PIX payments, installments, cancellations, receipt printing, and more.
+[![npm version](https://badge.fury.io/js/react-native-pos-pagseguro.svg)](https://badge.fury.io/js/react-native-pos-pagseguro)
+[![Platform](https://img.shields.io/badge/platform-Android-yellow.svg)](https://www.android.com)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+- **Initialize and activate** PagSeguro terminals
+- **Payments:** Credit, Debit, Voucher, PIX
+- **Installments:** (à vista, store installment without interest, buyer installment with interest)
+- **Cancel/refund:** transactions (same-day only)
+- Get last approved transaction
+- **Reprint:** customer or merchant receipt
+- Custom image printing (file path or Base64)
+- Abort ongoing operations
+- Reboot terminal
+- **Device info:** model, serial number, user data, sub-acquirer data
+- **Capability detection:** printer, NFC, chip, magnetic stripe, etc.
+- Progress callbacks during payment flow
+
+## Installation
+
+```bash
+npm install react-native-pos-pagseguro
+```
+## or
+```bash
+yarn add react-native-pos-pagseguro
+```
+### Post-install steps
+
+Since this library uses **react-native-nitro-modules**, you need to rebuild your app after installation:
+
+```bash
+npx react-native run-android  
+```
+
+
+## Requirements
+
+- **Platform**: Android only
+- React Native ≥ 0.71
+- react-native-nitro-modules ≥ 0.30 (for older RN versions)
+
+## Usage
+
+### 1. Initialize the terminal (required first step)
+
+```typescript
+import PagSeguro from 'react-native-pos-pagseguro';
+
+// Must be called once with your activation code provided by PagSeguro
+try {
+  PagSeguro.initialize('YOUR_ACTIVATION_CODE_HERE');
+  console.log('Terminal initialized successfully');
+} catch (error) {
+  console.error('Initialization failed:', error);
+}
+```
+
+
+### 2. Make a payment
+```typescript
+import PagSeguro, { PaymentTypes, InstallmentTypes } from 'react-native-pos-pagseguro';
+
+try {
+  const result = await PagSeguro.do_payment({
+    amount: 1000, // R$ 10,00 (in cents)
+    type: PaymentTypes.CREDIT,
+    installment_type: InstallmentTypes.SELLER_INSTALLMENT,
+    installments: 3,
+    print_receipt: true,
+    user_reference: 12345, // optional
+  }, (statusMessage) => {
+    console.log('Progress:', statusMessage); // e.g., "APROXIME, INSIRA OU PASSE O CARTÃO"
+  });
+
+  console.log('Payment approved!', result.transaction_code, result.nsu);
+} catch (error) {
+  console.error('Payment failed:', error.code, error.message);
+}
+```
+
+
+### 3. Cancel a payment (same day only)
+```typescript
+try {
+  const cancelResult = await PagSeguro.void_payment({
+    transaction_code: '123456789',
+    transaction_id: 'ABCDEF123456',
+    print_receipt: true,
+  }, (statusMessage) => {
+    console.log('Progress:', statusMessage); // e.g., "APROXIME, INSIRA OU PASSE O CARTÃO"
+  });
+
+  console.log('Cancellation successful:', cancelResult);
+} catch (error) {
+  console.error('Cancellation failed:', error);
+}
+```
+
+
+### 4. Reprint receipts
+```typescript
+try {
+  await PagSeguro.reprint_customer_receipt();
+  console.log('Customer receipt reprinted');
+} catch (error) {
+  console.error('Print failed:', error);
+}
+```
+
+### 5. Check device capabilities
+```typescript
+if (PagSeguro.capabilities.has_printer()) {
+  console.log('This terminal has a thermal printer');
+}
+
+if (PagSeguro.capabilities.has_picc()) {
+  console.log('Supports contactless (NFC) payments');
+}
+```
+
+### 6. Get device info
+```typescript
+console.log('Model:', PagSeguro.get_model());
+console.log('Serial:', PagSeguro.get_serial_number());
+console.log('User data:', PagSeguro.get_userdata());
+```
+
+## Error Handling
+
+
+- `PaymentError` – Payment, validation, or communication issues
+- `PrintError` – Printing or reprinting failures
+- `AbordError` – Failure when trying to abort an operation
+```typescript
+try {
+  await PagSeguro.do_payment(data);
+} catch (e) {
+  if (e instanceof PaymentError) {
+    console.log('Payment error:', e.code, e.message);
+  }
+}
+```
+
+## API Reference
+
+All types and enums are fully typed. Key exports:
+
+- `PaymentData`
+- `TransactionResult`
+- `VoidPayData`
+- `PaymentTypes`
+- `InstallmentTypes`
+- `VoidType`
+- `capabilities` (object with detection methods)
+
+## Contributing
+
+Contributions are welcome! To contribute:
+
+1. Fork the repository.
+2. Create a feature branch (`git checkout -b feature/your-feature`).
+3. Commit your changes (`git commit -m 'Add your feature'`).
+4. Push to the branch (`git push origin feature/your-feature`).
+5. Open a pull request.
+
+Please include tests and update documentation as needed.
+
+## Support the Project ☕
+
+If you've found this library helpful, consider buying me a coffee!
+
+
+
+Scan the QR code to donate (Lightning⚡):
+
+![Lightning donation QR code for cecsmh@bipa.app](https://api.qrserver.com/v1/create-qr-code/?data=lightning:cecsmh@bipa.app&size=300x300&ecc=M)
+
+Thank you for your support! 🚀
+
+## License
+
+MIT License. See LICENSE for details.
+
+## Support
+
+For issues or questions, open an issue on the GitHub repository or contact the maintainers.

package/android/CMakeLists.txt

@@ -0,0 +1,24 @@
+project(pospagseguro)
+cmake_minimum_required(VERSION 3.9.0)
+
+set(PACKAGE_NAME pospagseguro)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 20)
+
+# Define C++ library and add all sources
+add_library(${PACKAGE_NAME} SHARED src/main/cpp/cpp-adapter.cpp)
+
+# Add Nitrogen specs :)
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/pospagseguro+autolinking.cmake)
+
+# Set up local includes
+include_directories("src/main/cpp" "../cpp")
+
+find_library(LOG_LIB log)
+
+# Link all libraries together
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        android # <-- Android core
+)

package/android/build.gradle

@@ -0,0 +1,132 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['PosPagseguro_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+    maven { url 'https://github.com/pagseguro/PlugPagServiceWrapper/raw/master' }
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+apply plugin: "com.android.library"
+apply plugin: "org.jetbrains.kotlin.android"
+apply plugin: "kotlin-android"
+apply from: '../nitrogen/generated/android/pospagseguro+autolinking.gradle'
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["PosPagseguro_" + name]).toInteger()
+}
+
+android {
+  namespace "com.margelo.nitro.pospagseguro"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+            "META-INF",
+            "META-INF/**",
+            "**/libc++_shared.so",
+            "**/libfbjni.so",
+            "**/libjsi.so",
+            "**/libfolly_json.so",
+            "**/libfolly_runtime.so",
+            "**/libglog.so",
+            "**/libhermes.so",
+            "**/libhermes-executor-debug.so",
+            "**/libhermes_executor.so",
+            "**/libreactnative.so",
+            "**/libreactnativejni.so",
+            "**/libturbomodulejsijni.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libjscexecutor.so"
+    ]
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+  maven { url 'https://github.com/pagseguro/PlugPagServiceWrapper/raw/master' }
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation(fileTree(dir: "libs", include: ["*.jar", "*.aar"]))
+  implementation "com.facebook.react:react-android"
+
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation project(":react-native-nitro-modules")
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+PosPagseguro_kotlinVersion=2.0.21
+PosPagseguro_minSdkVersion=24
+PosPagseguro_targetSdkVersion=34
+PosPagseguro_compileSdkVersion=35
+PosPagseguro_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,6 @@
+#include <jni.h>
+#include "pospagseguroOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return margelo::nitro::pospagseguro::initialize(vm);
+}

package/android/src/main/java/com/margelo/nitro/pospagseguro/PosPagseguro.kt

@@ -0,0 +1,251 @@
+package com.margelo.nitro.pospagseguro
+  
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.NitroModules 
+import com.margelo.nitro.core.NullType
+import com.margelo.nitro.pospagseguro.maps.*
+
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.ReactApplicationContext
+
+import br.com.uol.pagseguro.plugpagservice.wrapper.IPlugPagWrapper
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPag
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagPrinterData
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagActivationData
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagCommand
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagCustomPrinterLayout
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagEffectuatePreAutoData
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagEventData
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagEventListener
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagExtras
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagInitializationResult
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagInstallment
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagNFCResult
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagNearFieldCardData
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagPaymentData
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagPreAutoData
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagPreAutoKeyingData
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagPreAutoQueryData
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagPrintResult
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagPrinterListener
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagReceiptSMSData
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagStyleData
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagTransactionResult
+import br.com.uol.pagseguro.plugpagservice.wrapper.TerminalCapabilities
+import br.com.uol.pagseguro.plugpagservice.wrapper.PlugPagVoidData
+import br.com.uol.pagseguro.plugpagservice.wrapper.data.result.PlugPagCmdExchangeResult
+import br.com.uol.pagseguro.plugpagservice.wrapper.exception.PlugPagException
+import br.com.uol.pagseguro.plugpagservice.wrapper.listeners.PlugPagNFCListener
+import br.com.uol.pagseguro.plugpagservice.wrapper.listeners.PlugPagAbortListener
+import br.com.uol.pagseguro.plugpagservice.wrapper.listeners.PlugPagPaymentListener
+import br.com.uol.pagseguro.plugpagservice.wrapper.listeners.PlugPagSetStylesListener
+import br.com.uol.pagseguro.plugpagservice.wrapper.listeners.PlugPagActivationListener
+import br.com.uol.pagseguro.plugpagservice.wrapper.listeners.PlugPagPrintActionListener
+import br.com.uol.pagseguro.plugpagservice.wrapper.listeners.PlugPagIsActivatedListener
+import br.com.uol.pagseguro.plugpagservice.wrapper.listeners.PlugPagInstallmentsListener
+import br.com.uol.pagseguro.plugpagservice.wrapper.listeners.PlugPagAPDUCmdExchangeListener
+import br.com.uol.pagseguro.plugpagservice.wrapper.listeners.PlugPagLastTransactionListener
+
+import android.content.Context
+import android.util.Log
+import android.util.Base64
+import java.io.File
+import java.io.FileOutputStream
+
+@DoNotStrip
+class PosPagseguro : HybridPosPagseguroSpec() {
+  
+  private val androidContext: Context get() = NitroModules.applicationContext!!
+
+  private val plug_pag: IPlugPagWrapper by lazy { PlugPag(androidContext) }
+
+  override fun getModel(): String { return plug_pag.getModel(); }
+  override fun getSerialNumber(): String { return plug_pag.getSerialNumber(); }
+  override fun getSubAcquirerData(): SubAcquirer? { return plug_pag.getSubAcquirerData()?.toSubAcquirer()}
+  override fun getUserData(): UserData { return plug_pag.getUserData().toUserData() }
+
+  override fun isAuthenticated(): Boolean { return plug_pag.isAuthenticated(); }
+  override fun isServiceBusy(): Boolean { return plug_pag.isServiceBusy(); };
+
+  override fun reboot(): Unit { plug_pag.reboot(); }
+
+  override fun reprintCustomerReceipt(): Promise<Variant_Double_CustomError> {
+    return Promise.async {
+        val r = plug_pag.reprintCustomerReceipt();
+        if(r.result == PlugPag.RET_OK) return@async Variant_Double_CustomError.create(r.steps.toDouble());
+        else return@async Variant_Double_CustomError.create(CustomError(r.errorCode ?: "PRINTERR", r.message ?: "Ocorreu um erro ao tentar reimprimir via do cliente"));
+    }
+  }
+
+  override fun reprintStablishmentReceipt(): Promise<Variant_Double_CustomError> {
+    return Promise.async {
+        val r = plug_pag.reprintStablishmentReceipt();
+        if(r.result == PlugPag.RET_OK) return@async Variant_Double_CustomError.create(r.steps.toDouble());
+        else return@async Variant_Double_CustomError.create(CustomError(r.errorCode ?: "PRINTERR", r.message ?: "Ocorreu um erro ao tentar reimprimir via do estabelecimento"));
+    }
+  }
+
+  override fun printFromBase64(base_64: String, quality: Double, bottomPad: Double?): Promise<Variant_Double_CustomError> {
+    val bytes = Base64.decode(base_64, Base64.DEFAULT)
+
+    val cached_file = File(androidContext.cacheDir, "temp_file")
+
+    FileOutputStream(cached_file).use { fos ->
+        fos.write(bytes)
+        fos.flush()
+    }
+
+    return printFromFile(cached_file.absolutePath, quality, bottomPad);
+  }
+
+  override fun printFromFile(file_path: String, quality: Double, bottomPad: Double?): Promise<Variant_Double_CustomError> {
+    return Promise.async{
+        val q = quality.toInt();
+        val bp = bottomPad?.toInt() ?: PlugPag.MIN_PRINTER_STEPS
+
+        val r = plug_pag.printFromFile(PlugPagPrinterData(file_path, q, bp))
+        if(r.result == PlugPag.RET_OK) return@async Variant_Double_CustomError.create(r.steps.toDouble());
+        else return@async Variant_Double_CustomError.create(CustomError(r.errorCode ?: "PRINTERR", r.message ?: "Ocorreu um erro ao tentar imprimir arquivo"));
+    }
+  }
+
+  override fun hasCapability(capability: Capabilities): Boolean { return plug_pag.hasCapability(capability.value) }
+
+  override fun initialize(activation_code: String): Unit {
+    try {
+        val r = plug_pag.initializeAndActivatePinpad(PlugPagActivationData(activation_code))
+        if (r.result == PlugPag.RET_OK) return Unit
+        else throw Error("$r.errorCode: $r.errorMessage");
+    } catch (e: Exception) { throw Error("Ocorreu um erro ao inicializar terminal: $e.message"); }
+  }
+
+  override fun abort(): CustomError? {
+    var r = plug_pag.abort()
+    if (r.result == PlugPag.RET_OK) return null;
+    else return CustomError("OPR_ERROR", "Ocorreu um erro ao solicitar cancelamento");
+  }
+
+  override fun doPayment(payment_data: PaymentData, process_callback: (event: String) -> Unit): Promise<Variant_CustomError_TransactionResult> {
+    return Promise.async {
+            try {
+                if (!plug_pag.isAuthenticated()) return@async Variant_CustomError_TransactionResult.create(CustomError("AUTH", "POS não autenticado!"));
+
+                @Suppress("REDUNDANT_ELSE_IN_WHEN")
+                val type = when (payment_data.type) {
+                    PaymentTypes.CREDIT -> PlugPag.TYPE_CREDITO
+                    PaymentTypes.DEBIT -> PlugPag.TYPE_DEBITO
+                    PaymentTypes.PIX -> PlugPag.TYPE_PIX
+                    PaymentTypes.VOUCHER -> PlugPag.TYPE_VOUCHER
+                    else -> return@async Variant_CustomError_TransactionResult.create(CustomError("INVALID_PARAM","Tipo de pagamento inválido"))
+                }
+
+                @Suppress("REDUNDANT_ELSE_IN_WHEN")
+                val installment_type = when (payment_data.installment_type) {
+                    InstallmentTypes.NO_INSTALLMENT -> PlugPag.INSTALLMENT_TYPE_A_VISTA
+                    InstallmentTypes.SELLER_INSTALLMENT -> PlugPag.INSTALLMENT_TYPE_PARC_VENDEDOR
+                    InstallmentTypes.BUYER_INSTALLMENT -> PlugPag.INSTALLMENT_TYPE_PARC_COMPRADOR
+                    else -> return@async Variant_CustomError_TransactionResult.create(CustomError("INVALID_PARAM", "Tipo de parcelamento inválido"))
+                }
+
+                val payment_data = PlugPagPaymentData(
+                    type = type,
+                    amount = payment_data.amount.toInt(),
+                    installmentType = installment_type,
+                    installments = payment_data.installments.toInt(),
+                    userReference = payment_data.user_reference?.toInt().toString() ?: "",
+                    printReceipt = payment_data.print_receipt ?: true,
+                    partialPay = false,
+                    isCarne = false
+                )
+
+                var password_count = 0;
+
+                plug_pag.setEventListener(object : PlugPagEventListener {
+                    override fun onEvent(data: PlugPagEventData) {
+                        val msg = when (data.eventCode) {
+                            PlugPagEventData.EVENT_CODE_DIGIT_PASSWORD -> {
+                                password_count++
+                                "SENHA: "+("*".repeat(password_count))
+                            }
+                            PlugPagEventData.EVENT_CODE_NO_PASSWORD -> {
+                                password_count = 0
+                                "DIGITE A SENHA"
+                            }
+                            else -> data.customMessage ?: "AGUARDANDO..."
+                        }
+                        process_callback(msg);
+                    }
+                })
+
+                val result = plug_pag.doPayment(paymentData = payment_data)
+
+                if (result.result == PlugPag.RET_OK) {
+                    return@async Variant_CustomError_TransactionResult.create(result.toTransactionResult())
+                } else {
+                    plug_pag.abort();
+                    var code = result.errorCode ?: "OPR_ERROR";
+                    var msg = result.message ?: "Ocorreu um erro ao tentar executar a transação.";
+                    return@async Variant_CustomError_TransactionResult.create(CustomError(code, msg))
+                }
+            } catch (e: PlugPagException) {
+                throw Error("Erro ao realizar pagamento: $e.message");
+            } catch (e: Exception) {
+                throw Error("Erro inesperado: $e.message");
+            }
+            return@async Variant_CustomError_TransactionResult.create(CustomError("sdad", "dasdad"))
+        }
+    }
+
+    override fun voidPayment(void_data: VoidPayData, process_callback: (event: String) -> Unit): Promise<Variant_CustomError_TransactionResult> {
+        return Promise.async {
+            try {
+                plug_pag.setEventListener(object : PlugPagEventListener {
+                    override fun onEvent(data: PlugPagEventData) {
+                        val msg = when (data.eventCode) {
+                            PlugPagEventData.EVENT_CODE_DIGIT_PASSWORD -> {
+                             
+                                "SENHA: *"
+                            }
+                            PlugPagEventData.EVENT_CODE_NO_PASSWORD -> {
+
+                                "DIGITE A SENHA"
+                            }
+                            else -> data.customMessage ?: "AGUARDANDO..."
+                        }
+                        process_callback(msg);
+                    }
+                })
+                val r = plug_pag.voidPayment(PlugPagVoidData(
+                    transactionCode = void_data.transaction_code,
+                    transactionId = void_data.transaction_id,
+                    printReceipt = void_data.print_receipt?: false,
+                    voidType = when(void_data.void_type) {
+                        VoidType.PAYMENT -> PlugPag.VOID_PAYMENT 
+                        VoidType.QRCODE -> PlugPag.VOID_QRCODE
+                        else -> PlugPag.VOID_PAYMENT
+                    }
+                ))
+
+                if (r.result == PlugPag.RET_OK) return@async Variant_CustomError_TransactionResult.create(r.toTransactionResult())
+                else {
+                    var code = r.errorCode ?: "OPR_ERROR";
+                    var msg = r.message ?: "Ocorreu um erro ao tentar executar a transação.";
+                    return@async Variant_CustomError_TransactionResult.create(CustomError(code, msg))
+                } 
+            } catch (e: PlugPagException) {
+                throw Error("Erro ao realizar pagamento: $e.message");
+            } catch (e: Exception) {
+                throw Error("Erro inesperado: $e.message");
+            }
+        }
+    }
+
+    override fun getLastApprovedTransaction(): Variant_CustomError_TransactionResult {
+        val r = plug_pag.getLastApprovedTransaction()   
+        if (r.result == PlugPag.RET_OK) return Variant_CustomError_TransactionResult.create(r.toTransactionResult());
+
+        var code = r.errorCode ?: "OPR_ERROR";
+        var msg = r.message ?: "Ocorreu um erro ao requisitar ultima transação.";
+        return Variant_CustomError_TransactionResult.create(CustomError(code, msg));
+    }
+}