react-native-wireguard-vpn-patched 1.0.22-patch.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Usama Aamir {Feline Predator}
+
+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/README.md

@@ -0,0 +1,238 @@
+# react-native-wireguard-vpn-patched
+
+A production-ready fork of [`react-native-wireguard-vpn`](https://github.com/usama7365/react-native-wireguard-vpn) (v1.0.22) with two critical Android fixes applied that are required for real-world VPN application deployment.
+
+**Author:** Abdul Ahad — [github.com/AbdulAHAD968](https://github.com/AbdulAHAD968)
+**Base package:** `react-native-wireguard-vpn@1.0.22` by usama7365 (MIT)
+
+---
+
+## Why This Fork Exists
+
+The original `react-native-wireguard-vpn` package has two production-blocking issues on Android:
+
+**1. VPN Permission Not Requested**
+
+Android requires explicit user consent before any app can establish a VPN tunnel (`VpnService.prepare()`). The original `connect()` method skipped this check entirely, causing silent failures or crashes on devices where the permission had not been pre-granted. There was no mechanism for the app to know permission was needed, and no way to present the system dialog.
+
+**2. No Split Tunneling Support**
+
+The original module provided no way to exclude specific applications from the VPN tunnel. Android exposes `VpnService.Builder.addDisallowedApplication()` (API 21+) for this purpose, but it was not wired up in the native module. Any production VPN application is expected to offer this as a user-facing feature.
+
+---
+
+## Changes in This Fork
+
+### Android — `WireGuardVpnModule.kt`
+
+#### Fix 1: VPN Permission Request
+
+Before the tunnel is brought up, `VpnService.prepare()` is now called. If the permission dialog needs to be shown, the native module:
+
+- Launches the system intent via `startActivityForResult(intent, 1000)`
+- Rejects the connect promise with error code `VPN_PERMISSION_REQUIRED`
+- Returns immediately — the tunnel is not started
+
+The caller handles `VPN_PERMISSION_REQUIRED` and re-calls `connect()` after the user grants permission (via `AppState` change detection or equivalent).
+
+```kotlin
+val intent = VpnService.prepare(reactApplicationContext)
+if (intent != null) {
+    val activity = getCurrentActivity()
+    if (activity != null) {
+        activity.startActivityForResult(intent, 1000)
+        promise.reject("VPN_PERMISSION_REQUIRED", "Please accept the Android VPN permission dialog.")
+        return
+    }
+}
+```
+
+#### Fix 2: Split Tunneling via `excludedApps`
+
+The `connect()` method now accepts an optional `excludedApps` string array. Each entry is an Android package name. The native module calls `interfaceBuilder.excludeApplication(packageName)` for each, routing those apps outside the VPN tunnel. Failures for individual packages are logged and non-fatal.
+
+```kotlin
+if (config.hasKey("excludedApps")) {
+    val excludedApps = config.getArray("excludedApps")?.toArrayList()
+    excludedApps?.forEach { app ->
+        (app as? String)?.let { packageName ->
+            try {
+                interfaceBuilder.excludeApplication(packageName)
+            } catch (e: Exception) {
+                println("Failed to exclude app $packageName: ${e.message}")
+            }
+        }
+    }
+}
+```
+
+---
+
+## Installation
+
+```bash
+npm install react-native-wireguard-vpn-patched
+# or
+yarn add react-native-wireguard-vpn-patched
+```
+
+If you are migrating from `react-native-wireguard-vpn`, uninstall it first:
+
+```bash
+npm uninstall react-native-wireguard-vpn
+```
+
+---
+
+## Usage
+
+```typescript
+import WireGuard from 'react-native-wireguard-vpn-patched';
+import { AppState } from 'react-native';
+
+// Initialize once on app start
+await WireGuard.initialize();
+
+// Basic connection
+await WireGuard.connect({
+  privateKey: '<client-private-key>',
+  publicKey: '<server-public-key>',
+  serverAddress: '203.0.113.1',
+  serverPort: 51820,
+  address: '10.64.0.2/32',
+  allowedIPs: ['0.0.0.0/0', '::/0'],
+  dns: ['1.1.1.1', '8.8.8.8'],
+  mtu: 1420,
+});
+```
+
+### Handling VPN Permission (Android)
+
+```typescript
+import { AppState } from 'react-native';
+
+const connect = async () => {
+  try {
+    await WireGuard.connect(config);
+    // tunnel is up
+  } catch (err) {
+    if (err.code === 'VPN_PERMISSION_REQUIRED') {
+      // System dialog is now visible to the user.
+      // Listen for the app coming back to foreground, then retry.
+      const sub = AppState.addEventListener('change', async (state) => {
+        if (state === 'active') {
+          sub.remove();
+          await WireGuard.connect(config); // second call succeeds if user accepted
+        }
+      });
+    }
+  }
+};
+```
+
+### Split Tunneling
+
+Pass an `excludedApps` array of Android package names. Those apps will route through the device's regular internet connection, bypassing the VPN tunnel.
+
+```typescript
+await WireGuard.connect({
+  // ...base config...
+  excludedApps: [
+    'com.google.android.apps.maps',
+    'com.example.bankingapp',
+  ],
+});
+```
+
+---
+
+## API Reference
+
+### `WireGuard.initialize(): Promise<void>`
+
+Initializes the WireGuard Go backend. Must be called once before `connect()`.
+
+### `WireGuard.connect(config: WireGuardConfig): Promise<void>`
+
+Establishes the VPN tunnel. Rejects with `VPN_PERMISSION_REQUIRED` on first run on Android if the user has not yet granted VPN permission.
+
+### `WireGuard.disconnect(): Promise<void>`
+
+Tears down the active tunnel.
+
+### `WireGuard.getStatus(): Promise<WireGuardStatus>`
+
+Returns the current tunnel state.
+
+### `WireGuard.isSupported(): Promise<boolean>`
+
+Returns `true` if WireGuard is supported on the current device.
+
+---
+
+## Types
+
+```typescript
+interface WireGuardConfig {
+  privateKey: string;
+  publicKey: string;
+  serverAddress: string;
+  serverPort: number;
+  address?: string | string[];   // tunnel interface IP, e.g. "10.64.0.2/32"
+  allowedIPs: string[];          // routing rules, e.g. ["0.0.0.0/0", "::/0"]
+  dns?: string[];
+  mtu?: number;
+  presharedKey?: string;
+  excludedApps?: string[];       // Android only — package names to bypass VPN
+}
+
+interface WireGuardStatus {
+  isConnected: boolean;
+  tunnelState: 'ACTIVE' | 'INACTIVE' | 'CONNECTING' | 'DISCONNECTING' | 'ERROR' | 'UNKNOWN';
+  status: 'CONNECTED' | 'DISCONNECTED' | 'CONNECTING' | 'DISCONNECTING' | 'ERROR' | 'UNKNOWN';
+  error?: string;
+}
+```
+
+---
+
+## Requirements
+
+| Requirement      | Minimum Version |
+|------------------|-----------------|
+| React Native     | 0.72.0          |
+| Android API      | 21 (Android 5)  |
+| compileSdkVersion| 34              |
+| Kotlin           | 1.8.0           |
+
+---
+
+## Platform Support
+
+| Platform | Permission Fix | Split Tunneling |
+|----------|---------------|-----------------|
+| Android  | Yes           | Yes             |
+| iOS      | N/A (handled by OS) | Not yet    |
+
+iOS split tunneling is not implemented in this fork. The iOS implementation is unchanged from the upstream package.
+
+---
+
+## Differences from Upstream
+
+| Feature                        | `react-native-wireguard-vpn` | This fork |
+|--------------------------------|------------------------------|-----------|
+| Android VPN permission request | No                           | Yes       |
+| Split tunneling (`excludedApps`) | No                         | Yes       |
+| `VPN_PERMISSION_REQUIRED` error code | No                   | Yes       |
+| TypeScript: `excludedApps` field | No                        | Yes       |
+| Base version                   | 1.0.22                       | 1.0.22-patch.2 |
+
+---
+
+## License
+
+MIT — same as the upstream package.
+
+Original package copyright: usama7365  
+Fork modifications copyright: Abdul Ahad (ahad06074@gmail.com)

package/android/build.gradle

@@ -0,0 +1,60 @@
+buildscript {
+    ext.kotlin_version = '1.8.0'
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.1.0'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+allprojects {
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+android {
+    compileSdkVersion 34
+    namespace "com.wireguardvpn"
+
+    defaultConfig {
+        minSdkVersion 21
+        targetSdkVersion 34
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = '17'
+    }
+
+    sourceSets {
+        main {
+            manifest.srcFile 'src/main/AndroidManifest.xml'
+            res.srcDirs = ['src/main/res']
+        }
+    }
+}
+
+dependencies {
+    implementation "com.facebook.react:react-native:+"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+    implementation 'com.wireguard.android:tunnel:1.0.20211029'
+} 

package/android/src/main/java/com/wireguardvpn/WireGuardVpnModule.kt

@@ -0,0 +1,353 @@
+package com.wireguardvpn
+
+import android.net.VpnService
+import android.app.Activity
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.wireguard.android.backend.GoBackend
+import com.wireguard.config.Config
+import com.wireguard.config.Interface
+import com.wireguard.config.Peer
+import com.wireguard.android.backend.Tunnel
+import java.net.InetAddress
+import com.wireguard.config.InetNetwork
+import com.wireguard.config.ParseException
+import com.wireguard.crypto.Key
+
+class WireGuardVpnModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+    private var backend: GoBackend? = null
+    private var tunnel: Tunnel? = null
+    private var config: Config? = null
+
+    private fun emitVpnState(tunnelState: String, status: String, isConnected: Boolean) {
+        val payload = Arguments.createMap().apply {
+            putBoolean("isConnected", isConnected)
+            putString("tunnelState", tunnelState)
+            putString("status", status)
+        }
+        reactApplicationContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit("vpnStateChanged", payload)
+    }
+
+    private fun mapTunnelState(newState: Tunnel.State): Triple<String, String, Boolean> {
+        val stateName = newState?.name ?: "UNKNOWN"
+        val tunnelState = when {
+            newState == Tunnel.State.UP -> "ACTIVE"
+            newState == Tunnel.State.DOWN -> "INACTIVE"
+            stateName.contains("CONNECT", ignoreCase = true) -> "CONNECTING"
+            stateName.contains("DISCONNECT", ignoreCase = true) -> "DISCONNECTING"
+            else -> "ERROR"
+        }
+
+        val status = when (tunnelState) {
+            "ACTIVE" -> "CONNECTED"
+            "INACTIVE" -> "DISCONNECTED"
+            "CONNECTING" -> "CONNECTING"
+            "DISCONNECTING" -> "DISCONNECTING"
+            "ERROR" -> "ERROR"
+            else -> "UNKNOWN"
+        }
+
+        return Triple(tunnelState, status, newState == Tunnel.State.UP)
+    }
+
+    override fun getName() = "WireGuardVpnModule"
+
+    @ReactMethod
+    fun initialize(promise: Promise) {
+        try {
+            backend = GoBackend(reactApplicationContext)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("INIT_ERROR", "Failed to initialize WireGuard: ${e.message}")
+        }
+    }
+
+    @ReactMethod
+    fun connect(config: ReadableMap, promise: Promise) {
+        try {
+            println("Starting VPN connection process...")
+            
+            // --- SURGICAL PERMISSION CHECK ---
+            val intent = VpnService.prepare(reactApplicationContext)
+            if (intent != null) {
+                val activity = getCurrentActivity()
+                if (activity != null) {
+                    activity.startActivityForResult(intent, 1000)
+                    promise.reject("VPN_PERMISSION_REQUIRED", "Please accept the Android VPN permission dialog.")
+                    return
+                }
+            }
+            // ---------------------------------
+
+            println("Received config: $config")
+            
+            if (backend == null) {
+                println("Backend is null, initializing...")
+                backend = GoBackend(reactApplicationContext)
+            }
+            
+            val interfaceBuilder = Interface.Builder()
+            
+            // Parse private key
+            val privateKey = config.getString("privateKey") ?: throw Exception("Private key is required")
+            try {
+                println("Parsing private key: $privateKey")
+                interfaceBuilder.parsePrivateKey(privateKey)
+                println("Private key parsed successfully")
+            } catch (e: ParseException) {
+                println("Failed to parse private key: ${e.message}")
+                throw Exception("Invalid private key format: ${e.message}, Key: $privateKey")
+            }
+            
+            // Interface address: client's VPN tunnel IP (e.g. 10.64.0.1/32). Do NOT use allowedIPs here
+            // or the Go backend can return "Bad address" (0.0.0.0/0 or ::/0 are invalid for interface).
+            val rawAddress = when {
+                config.hasKey("address") && config.getType("address") == ReadableType.Array ->
+                    config.getArray("address")?.toArrayList().orEmpty()
+                config.hasKey("address") && config.getString("address") != null ->
+                    listOf(config.getString("address")!!)
+                else -> listOf("10.64.0.1/32")
+            }
+            val interfaceAddresses = rawAddress.filterIsInstance<String>().map { it.trim() }.filter { it.isNotBlank() }
+                .ifEmpty { listOf("10.64.0.1/32") }
+            try {
+                interfaceAddresses.forEach { addr ->
+                    interfaceBuilder.addAddress(InetNetwork.parse(addr))
+                }
+            } catch (e: ParseException) {
+                throw Exception("Invalid interface address format: ${e.message}. Use CIDR like 10.64.0.1/32, not 0.0.0.0/0. Addresses: $interfaceAddresses")
+            }
+
+            // Peer allowed IPs: which traffic to route through VPN (e.g. 0.0.0.0/0, ::/0)
+            val allowedIPs = config.getArray("allowedIPs")?.toArrayList()
+                ?: throw Exception("allowedIPs array is required")
+            val normalizedAllowedIPs = allowedIPs.mapNotNull { ip ->
+                (ip as? String)?.trim()?.takeIf { it.isNotBlank() }
+                    ?.replace("::0/0", "::/0") // normalize IPv6 default route (e.g. Mullvad)
+            }
+            if (normalizedAllowedIPs.isEmpty()) throw Exception("allowedIPs must contain at least one CIDR")
+
+            // Parse DNS servers
+            if (config.hasKey("dns")) {
+                val dnsServers = config.getArray("dns")?.toArrayList()
+                try {
+                    println("Parsing DNS servers: $dnsServers")
+                    dnsServers?.forEach { dns ->
+                        (dns as? String)?.let { dnsString ->
+                            interfaceBuilder.addDnsServer(InetAddress.getByName(dnsString))
+                        }
+                    }
+                    println("DNS servers parsed successfully")
+                } catch (e: Exception) {
+                    println("Failed to parse DNS servers: ${e.message}")
+                    throw Exception("Invalid DNS server format: ${e.message}, DNS: $dnsServers")
+                }
+            }
+
+            // Set MTU if provided
+            if (config.hasKey("mtu")) {
+                val mtu = config.getInt("mtu")
+                if (mtu < 1280 || mtu > 65535) {
+                    throw Exception("MTU must be between 1280 and 65535, got: $mtu")
+                }
+                interfaceBuilder.setMtu(mtu)
+            }
+
+            // Split Tunneling: exclude apps from VPN tunnel
+            if (config.hasKey("excludedApps")) {
+                val excludedApps = config.getArray("excludedApps")?.toArrayList()
+                excludedApps?.forEach { app ->
+                    (app as? String)?.let { packageName ->
+                        try {
+                            interfaceBuilder.excludeApplication(packageName)
+                            println("Excluded app from VPN: $packageName")
+                        } catch (e: Exception) {
+                            println("Failed to exclude app $packageName: ${e.message}")
+                        }
+                    }
+                }
+            }
+
+            val peerBuilder = Peer.Builder()
+            
+            // Parse public key
+            val publicKey = config.getString("publicKey") ?: throw Exception("Public key is required")
+            try {
+                println("Parsing public key: $publicKey")
+                peerBuilder.parsePublicKey(publicKey)
+                println("Public key parsed successfully")
+            } catch (e: ParseException) {
+                println("Failed to parse public key: ${e.message}")
+                throw Exception("Invalid public key format: ${e.message}, Key: $publicKey")
+            }
+            
+            // Parse preshared key if provided
+            if (config.hasKey("presharedKey")) {
+                val presharedKey = config.getString("presharedKey")
+                try {
+                    println("Parsing preshared key: $presharedKey")
+                    presharedKey?.let { keyString ->
+                        val key = Key.fromBase64(keyString)
+                        peerBuilder.setPreSharedKey(key)
+                    }
+                    println("Preshared key parsed successfully")
+                } catch (e: Exception) {
+                    println("Failed to parse preshared key: ${e.message}")
+                    throw Exception("Invalid preshared key format: ${e.message}, Key: $presharedKey")
+                }
+            }
+            
+            // Parse endpoint
+            val serverAddress = config.getString("serverAddress") ?: throw Exception("Server address is required")
+            val serverPort = config.getInt("serverPort")
+            if (serverPort < 1 || serverPort > 65535) {
+                throw Exception("Port must be between 1 and 65535, got: $serverPort")
+            }
+            val endpoint = "$serverAddress:$serverPort"
+            try {
+                println("Parsing endpoint: $endpoint")
+                peerBuilder.parseEndpoint(endpoint)
+                println("Endpoint parsed successfully")
+            } catch (e: ParseException) {
+                println("Failed to parse endpoint: ${e.message}")
+                throw Exception("Invalid endpoint format: ${e.message}, Endpoint: $endpoint")
+            }
+
+            // Add allowed IPs to peer (routing; do not use for interface address)
+            try {
+                normalizedAllowedIPs.forEach { ipString ->
+                    peerBuilder.addAllowedIp(InetNetwork.parse(ipString))
+                }
+            } catch (e: ParseException) {
+                throw Exception("Invalid peer allowedIP format: ${e.message}. Use ::/0 for IPv6 default, not ::0/0. IPs: $normalizedAllowedIPs")
+            }
+
+            println("Building WireGuard config...")
+            val configBuilder = Config.Builder()
+            configBuilder.setInterface(interfaceBuilder.build())
+            configBuilder.addPeer(peerBuilder.build())
+
+            this.config = configBuilder.build()
+            println("WireGuard config built successfully")
+
+            this.tunnel = object : Tunnel {
+                override fun getName(): String = "WireGuardTunnel"
+                override fun onStateChange(newState: Tunnel.State) {
+                    println("WireGuard tunnel state changed to: $newState")
+                    val (tunnelState, simpleStatus, isConnected) = mapTunnelState(newState)
+                    emitVpnState(tunnelState, simpleStatus, isConnected)
+                }
+            }
+
+            try {
+                println("Checking backend and tunnel state...")
+                println("Backend initialized: $backend")
+                println("Tunnel initialized: $tunnel")
+                println("Config ready: $config")
+
+                println("Attempting to set tunnel state to UP...")
+                if (backend == null) {
+                    throw Exception("Backend is null")
+                }
+                if (tunnel == null) {
+                    throw Exception("Tunnel is null")
+                }
+                if (this.config == null) {
+                    throw Exception("Config is null")
+                }
+                backend?.setState(tunnel!!, Tunnel.State.UP, this.config!!)
+                println("Successfully set tunnel state to UP")
+                promise.resolve(null)
+            } catch (e: Exception) {
+                val msg = e.message ?: e.toString()
+                val causeMsg = e.cause?.message
+                println("Failed to set tunnel state: $msg")
+                if (causeMsg != null) println("Cause: $causeMsg")
+                e.printStackTrace()
+                throw Exception(if (causeMsg != null) "$msg: $causeMsg" else msg)
+            }
+        } catch (e: Exception) {
+            val msg = e.message ?: e.toString()
+            val causeMsg = e.cause?.message
+            val fullMsg = buildString {
+                append(msg)
+                if (causeMsg != null) append(" (cause: $causeMsg)")
+                if (msg.contains("Bad address", ignoreCase = true) || msg.contains("BackendException", ignoreCase = true)) {
+                    append(". Tip: ensure 'address' is a tunnel CIDR like 10.64.0.1/32, not 0.0.0.0/0; use allowedIPs only for routing.")
+                }
+            }
+            println("Connection failed: $fullMsg")
+            e.printStackTrace()
+            promise.reject("CONNECT_ERROR", fullMsg)
+        }
+    }
+
+    @ReactMethod
+    fun disconnect(promise: Promise) {
+        try {
+            if (tunnel != null && backend != null && config != null) {
+                backend?.setState(tunnel!!, Tunnel.State.DOWN, config!!)
+                promise.resolve(null)
+            } else {
+                promise.reject("DISCONNECT_ERROR", "Tunnel not initialized")
+            }
+        } catch (e: Exception) {
+            promise.reject("DISCONNECT_ERROR", "Failed to disconnect: ${e.message}")
+        }
+    }
+
+    @ReactMethod
+    fun getStatus(promise: Promise) {
+        try {
+            val state = if (tunnel != null && backend != null) {
+                backend?.getState(tunnel!!)
+            } else {
+                Tunnel.State.DOWN
+            }
+
+            val stateName = state?.name ?: "UNKNOWN"
+
+            val tunnelState = when (state) {
+                Tunnel.State.UP -> "ACTIVE"
+                Tunnel.State.DOWN -> "INACTIVE"
+                else -> {
+                    // Tunnel.State enum name mapping is best-effort.
+                    if (stateName.contains("CONNECT", ignoreCase = true)) "CONNECTING"
+                    else if (stateName.contains("DISCONNECT", ignoreCase = true)) "DISCONNECTING"
+                    else "ERROR"
+                }
+            }
+
+            val simpleStatus = when (tunnelState) {
+                "ACTIVE" -> "CONNECTED"
+                "INACTIVE" -> "DISCONNECTED"
+                "CONNECTING" -> "CONNECTING"
+                "DISCONNECTING" -> "DISCONNECTING"
+                "ERROR" -> "ERROR"
+                else -> "UNKNOWN"
+            }
+
+            val out = Arguments.createMap().apply {
+                putBoolean("isConnected", state == Tunnel.State.UP)
+                putString("tunnelState", tunnelState)
+                putString("status", simpleStatus)
+            }
+            promise.resolve(out)
+        } catch (e: Exception) {
+            val status = Arguments.createMap().apply {
+                putBoolean("isConnected", false)
+                putString("tunnelState", "ERROR")
+                putString("status", "ERROR")
+                putString("error", e.message)
+            }
+            promise.resolve(status)
+        }
+    }
+
+    @ReactMethod
+    fun isSupported(promise: Promise) {
+        promise.resolve(true)
+    }
+} 

package/android/src/main/java/com/wireguardvpn/WireGuardVpnPackage.kt

@@ -0,0 +1,16 @@
+package com.wireguardvpn
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class WireGuardVpnPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(WireGuardVpnModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+} 

package/app.plugin.js

@@ -0,0 +1,4 @@
+// Expo config plugin entrypoint.
+// Expo resolves config plugins from this file when present.
+module.exports = require('./plugin/withWireGuardVpn');
+