@novastera-oss/nitro-metamask 0.6.3 → 0.7.2

package/NitroMetamask.podspec

@@ -14,19 +14,28 @@ Pod::Spec.new do |s|
   s.source       = { :git => "https://github.com/novastera/nitro-metamask.git", :tag => "#{s.version}" }
 
   s.source_files = [
-    # Implementation (Swift)
-    "ios/**/*.{swift}",
+    # Implementation (Swift) — exclude test directories
+    "ios/*.{swift}",
+    # Vendored MetaMask iOS SDK source
+    "ios/metamask-ios-sdk/**/*.{swift}",
     # Autolinking/Registration (Objective-C++)
     "ios/**/*.{m,mm}",
     # Implementation (C++ objects)
     "cpp/**/*.{hpp,cpp}",
   ]
 
+  s.vendored_frameworks = 'ios/Frameworks/Ecies.xcframework'
+
+  s.frameworks = 'UIKit', 'SwiftUI', 'Combine'
+
+  s.pod_target_xcconfig = {
+    'FRAMEWORK_SEARCH_PATHS' => '$(inherited) "$(PODS_XCFRAMEWORKS_BUILD_DIR)/NitroMetamask"'
+  }
+
   load 'nitrogen/generated/ios/NitroMetamask+autolinking.rb'
   add_nitrogen_files(s)
 
   s.dependency 'React-jsi'
   s.dependency 'React-callinvoker'
-  s.dependency 'metamask-ios-sdk', '~> 0.8.10'
   install_modules_dependencies(s)
 end

package/README.md

@@ -63,9 +63,11 @@ No extra Android configuration is required for consumers of this package.
 For app developers, the expected upgrade path is:
 
 1. Update to the new npm version.
-2. Clean install + clean Android build.
+2. Clean install + clean Android build (if you ever hit CMake / `react_codegen_*` / missing `codegen/jni` errors for this package, delete `android/app/.cxx` and `android/app/build`, then rebuild so autolinking regenerates).
 3. Rebuild release AAB/APK.
 
+**New Architecture:** this library is intended for apps with `newArchEnabled=true` (Nitro + Nitrogen); it does not register React Native’s Codegen `react_codegen_*` target.
+
 No manual Gradle dependency override should be needed in the consuming app.
 
 ### iOS Configuration

package/android/build.gradle

@@ -18,15 +18,14 @@ def isNewArchitectureEnabled() {
   return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
 }
 
+// Nitro hybrid module: native bindings come from nitrogen/generated (NitroMetamask+autolinking.gradle + CMake).
+// Do not apply com.facebook.react / react { libraryName } here — that registers RN New-Arch Codegen (react_codegen_*)
+// and breaks consumers (CMake expects android/build/generated/source/codegen/jni/ which this package never ships).
 apply plugin: "com.android.library"
 apply plugin: 'org.jetbrains.kotlin.android'
 apply from: '../nitrogen/generated/android/NitroMetamask+autolinking.gradle'
 apply from: "./fix-prefab.gradle"
 
-if (isNewArchitectureEnabled()) {
-  apply plugin: "com.facebook.react"
-}
-
 def getExtOrDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["NitroMetamask_" + name]
 }
@@ -98,6 +97,7 @@ android {
   buildFeatures {
     buildConfig true
     prefab true
+    aidl true
   }
 
   buildTypes {
@@ -117,13 +117,10 @@ android {
 
   sourceSets {
     main {
-      jniLibs.srcDirs += ["${buildDir}/intermediates/rust-ecies-jni"]
-      if (isNewArchitectureEnabled()) {
-        java.srcDirs += [
-          // React Codegen files
-          "${project.buildDir}/generated/source/codegen/java"
-        ]
-      }
+      // Local/CI build: libecies.so built from rust/ecies-jni via cargoNdkBuildEcies
+      // npm consumers: libecies.so shipped as prebuilt in android/src/main/jniLibs
+      jniLibs.srcDirs += ["${buildDir}/intermediates/rust-ecies-jni", "src/main/jniLibs"]
+      aidl.srcDirs += ["src/main/aidl"]
     }
   }
 }
@@ -133,13 +130,6 @@ repositories {
   google()
 }
 
-// Hard block old prebuilt ECIES .so from any transitive edge.
-// NitroMetamask always provides libecies.so from rust/ecies-jni (16 KB page-size compatible).
-configurations.configureEach {
-  exclude group: "io.metamask.ecies", module: "ecies"
-}
-
-
 dependencies {
   // For < 0.71, this will be from the local maven repo
   // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
@@ -153,19 +143,11 @@ dependencies {
   // Required for Promise.async with coroutines in Nitro modules
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.10.2"
 
-  // MetaMask Android SDK — exclude prebuilt io.metamask.ecies (4 KB ELF); we ship io.metamask.ecies.Ecies + libecies.so from rust/ecies-jni
-  // See: https://github.com/MetaMask/metamask-android-sdk/issues/157
-  implementation("io.metamask.androidsdk:metamask-android-sdk:0.6.6") {
-    exclude group: "io.metamask.ecies", module: "ecies"
-  }
-}
+  // Gson — used by vendored MetaMask SDK source for JSON serialization
+  implementation "com.google.code.gson:gson:2.11.0"
 
-apply from: "./cargo-ecies.gradle"
+  // ProcessLifecycleOwner — required for user cancellation detection (Requirement 11.4)
+  implementation "androidx.lifecycle:lifecycle-process:2.10.0"
+}
 
-if (isNewArchitectureEnabled()) {
-  react {
-    jsRootDir = file("../src/")
-    libraryName = "NitroMetamask"
-    codegenJavaPackageName = "com.margelo.nitro.nitrometamask"
-  }
-}
+apply from: "./cargo-ecies.gradle"

package/android/cargo-ecies.gradle

@@ -1,123 +1,95 @@
-def eciesRustDir = file("${projectDir}/../rust/ecies-jni")
-def eciesCargoToml = file("${projectDir}/../rust/ecies-jni/Cargo.toml")
-def eciesJniOut = file("${buildDir}/intermediates/rust-ecies-jni")
-def eciesPrebuiltDir = file("${projectDir}/src/main/jniLibs")
-def buildEciesFromSource = (project.findProperty("NitroMetamask_buildEciesFromSource") ?: "false").toString().toBoolean()
-
-def configuredAbis = ((rootProject.getProperties().get("reactNativeArchitectures"))?.split(",")
-  ?: ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]) as List<String>
-
-def hasCargoExecutable = { ->
-  def path = System.getenv("PATH") ?: ""
-  if (path.isEmpty()) {
-    return false
-  }
-
-  def names = ["cargo"]
-  def isWindows = (System.getProperty("os.name") ?: "").toLowerCase().contains("win")
-  if (isWindows) {
-    names = ["cargo.exe", "cargo.bat", "cargo.cmd"]
-  }
+// ─── ECIES native library build ───────────────────────────────────────────────
+//
+// Strategy:
+//   Local dev  → builds only the host ABI (fast, no cross-compilation needed)
+//   CI publish → builds all 4 ABIs via -PreactNativeArchitectures=arm64-v8a,...
+//
+// The built .so files land in:
+//   android/build/intermediates/rust-ecies-jni/<abi>/libecies.so
+// which is already on jniLibs.srcDirs in build.gradle.
+// ──────────────────────────────────────────────────────────────────────────────
 
-  for (dirPath in path.split(java.io.File.pathSeparator)) {
-    for (name in names) {
-      def candidate = new File(dirPath, name)
-      if (candidate.isFile() && candidate.canExecute()) {
-        return true
-      }
-    }
-  }
+def eciesRustDir   = file("${projectDir}/../rust/ecies-jni")
+def eciesCargoToml = file("${projectDir}/../rust/ecies-jni/Cargo.toml")
+def eciesJniOut    = file("${buildDir}/intermediates/rust-ecies-jni")
 
-  return false
+// Detect host ABI for local builds
+def hostAbi = { ->
+  def arch = System.getProperty("os.arch") ?: ""
+  if (arch.contains("aarch64") || arch.contains("arm64")) return "arm64-v8a"
+  if (arch.contains("x86_64") || arch.contains("amd64"))  return "x86_64"
+  return "arm64-v8a" // safe default for Apple Silicon Macs
 }
 
-def hasPrebuiltEciesForConfiguredAbis = { ->
-  def missing = []
-  configuredAbis.each { abi ->
-    def soFile = new File(eciesPrebuiltDir, "${abi}/libecies.so")
-    if (!soFile.isFile()) {
-      missing.add("${abi}/libecies.so")
-    }
-  }
-  return [available: missing.isEmpty(), missing: missing]
+// Resolve which ABIs to build:
+//   - If -PreactNativeArchitectures is set (CI), use that list
+//   - Otherwise build only the host ABI (local dev)
+def resolveAbis = { ->
+  def explicit = rootProject.getProperties().get("reactNativeArchitectures")
+  if (explicit) return explicit.split(",").toList()
+  return [hostAbi()]
 }
 
-tasks.register("verifyPrebuiltEciesLibs") {
-  group = "verification"
-  description = "Verify prebuilt libecies.so exists for all configured ABIs"
-
-  doLast {
-    def result = hasPrebuiltEciesForConfiguredAbis()
-    def missing = result.missing
-
-    if (!missing.isEmpty()) {
-      throw new GradleException(
-        "Missing prebuilt ECIES native libraries under android/src/main/jniLibs: ${missing.join(', ')}. " +
-        "If this is a source checkout, install Rust + cargo-ndk and build with " +
-        "-PNitroMetamask_buildEciesFromSource=true."
-      )
-    }
+// Find cargo/cargo-ndk — searches PATH then ~/.cargo/bin (rustup default)
+def findBin = { String name ->
+  def isWindows = (System.getProperty("os.name") ?: "").toLowerCase().contains("win")
+  def exeName = isWindows ? "${name}.exe" : name
+  def path = System.getenv("PATH") ?: ""
+  for (dir in path.split(java.io.File.pathSeparator)) {
+    def f = new File(dir, exeName)
+    if (f.isFile() && f.canExecute()) return f.absolutePath
+  }
+  def home = System.getProperty("user.home") ?: System.getenv("HOME") ?: ""
+  if (home) {
+    def f = new File("${home}/.cargo/bin/${exeName}")
+    if (f.isFile() && f.canExecute()) return f.absolutePath
   }
+  return null
 }
 
 tasks.register("cargoNdkBuildEcies", Exec) {
-  group = "build"
-  description = "Build libecies.so via Rust (maintainer-only)"
-  onlyIf {
-    def prebuiltStatus = hasPrebuiltEciesForConfiguredAbis()
-    (buildEciesFromSource || !prebuiltStatus.available) &&
-      eciesRustDir.isDirectory() && eciesCargoToml.isFile()
-  }
-  workingDir eciesRustDir
+  group       = "build"
+  description = "Build libecies.so from Rust source (local: host ABI only, CI: all ABIs)"
+  onlyIf      { eciesRustDir.isDirectory() && eciesCargoToml.isFile() }
+  workingDir  eciesRustDir
   standardOutput System.out
-  errorOutput System.err
+  errorOutput    System.err
   outputs.dir(eciesJniOut)
 }
 
-// Resolve NDK + ABIs at configuration time (afterEvaluate). Task actions must NOT touch
-// Task.project — configuration cache forbids it (see Gradle 9 config cache requirements).
 afterEvaluate {
   def ndkProp = project.android.ndkDirectory
-  def ndkDir = (ndkProp instanceof File) ? ndkProp : ndkProp.get().asFile
+  def ndkDir  = (ndkProp instanceof File) ? ndkProp : ndkProp.get().asFile
   def ndkPath = ndkDir.absolutePath
-  def ndkVer = project.android.ndkVersion
-  def abis = configuredAbis
+  def ndkVer  = project.android.ndkVersion
+  def abis    = resolveAbis()
   def outPath = eciesJniOut.absolutePath
+
   tasks.named("cargoNdkBuildEcies", Exec).configure {
     doFirst {
-      if (!hasCargoExecutable()) {
+      def cargo = findBin("cargo")
+      if (!cargo) {
         throw new GradleException(
-          "Cargo is not available. This build mode is maintainer-only. " +
-          "Run without -PNitroMetamask_buildEciesFromSource to use bundled prebuilt libraries."
+          "cargo not found. Install Rust: https://rustup.rs\n" +
+          "Then run: cargo install cargo-ndk --locked && rustup target add aarch64-linux-android armv7-linux-androideabi x86_64-linux-android i686-linux-android"
         )
       }
-
-      eciesJniOut.mkdirs()
       if (!ndkDir.exists()) {
-        throw new GradleException("ANDROID NDK not found; ndkVersion is ${ndkVer}")
+        throw new GradleException("Android NDK not found (ndkVersion=${ndkVer}). Install it via Android Studio SDK Manager.")
       }
+      eciesJniOut.mkdirs()
       environment "ANDROID_NDK_HOME", ndkPath
       environment "ANDROID_NDK_ROOT", ndkPath
       environment "RUSTFLAGS", "-C link-arg=-Wl,-z,max-page-size=16384"
-      def args = ["cargo", "ndk"]
-      abis.each { abi ->
-        args.add("-t")
-        args.add(abi)
-      }
-      args.addAll(["-o", outPath, "build", "--release"])
+      def args = [cargo, "ndk"]
+      abis.each { abi -> args += ["-t", abi] }
+      args += ["-o", outPath, "build", "--release"]
       commandLine args
+      logger.lifecycle("Building libecies.so for ABIs: ${abis.join(', ')}")
     }
   }
 
-  def prebuiltStatus = hasPrebuiltEciesForConfiguredAbis()
-  def canBuildFromSource = hasCargoExecutable() && eciesRustDir.isDirectory() && eciesCargoToml.isFile()
-  def shouldBuildFromSource = buildEciesFromSource || (!prebuiltStatus.available && canBuildFromSource)
-
   tasks.matching { it.name.startsWith("preBuild") }.configureEach {
-    if (shouldBuildFromSource) {
-      dependsOn("cargoNdkBuildEcies")
-    } else {
-      dependsOn("verifyPrebuiltEciesLibs")
-    }
+    dependsOn("cargoNdkBuildEcies")
   }
 }

package/android/src/main/aidl/io/metamask/nativesdk/IMessegeService.aidl

@@ -0,0 +1,8 @@
+// IMessegeService.aidl
+package io.metamask.nativesdk;
+import io.metamask.nativesdk.IMessegeServiceCallback;
+
+interface IMessegeService {
+    void registerCallback(in IMessegeServiceCallback callback);
+    void sendMessage(inout Bundle message);
+}

package/android/src/main/aidl/io/metamask/nativesdk/IMessegeServiceCallback.aidl

@@ -0,0 +1,8 @@
+// IMessegeServiceCallback.aidl
+package io.metamask.nativesdk;
+
+// Declare any non-default types here with import statements
+
+interface IMessegeServiceCallback {
+    void onMessageReceived(inout Bundle response);
+}

package/android/src/main/java/com/margelo/nitro/nitrometamask/HybridNitroMetamask.kt

@@ -3,7 +3,12 @@ package com.margelo.nitro.nitrometamask
 import android.content.Intent
 import android.content.pm.PackageManager
 import android.net.Uri
+import android.os.Handler
+import android.os.Looper
 import android.util.Log
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.ProcessLifecycleOwner
 import com.margelo.nitro.core.Promise
 import com.margelo.nitro.core.NullType
 import com.margelo.nitro.nitrometamask.HybridNitroMetamaskSpec
@@ -16,8 +21,10 @@ import io.metamask.androidsdk.Result
 import io.metamask.androidsdk.DappMetadata
 import io.metamask.androidsdk.SDKOptions
 import io.metamask.androidsdk.EthereumRequest
+import kotlinx.coroutines.CancellableContinuation
 import kotlinx.coroutines.suspendCancellableCoroutine
 import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
 
 class HybridNitroMetamask : HybridNitroMetamaskSpec() {
     // Configurable dapp URL - defaults to novastera.com if not set
@@ -40,7 +47,41 @@ class HybridNitroMetamask : HybridNitroMetamaskSpec() {
     // Cache the detected deep link scheme to avoid repeated detection
     @Volatile
     private var cachedDeepLinkScheme: String? = null
-    
+
+    // Pending operation cancellation handler — set when an operation is in-flight,
+    // cleared when the SDK callback arrives or when the foreground observer fires.
+    @Volatile
+    private var pendingOperationCancellation: (() -> Unit)? = null
+
+    init {
+        // addObserver must be called on the main thread — post to main looper
+        // since Nitro constructs hybrid objects on the JS thread.
+        Handler(Looper.getMainLooper()).post {
+            ProcessLifecycleOwner.get().lifecycle.addObserver(object : DefaultLifecycleObserver {
+                override fun onStart(owner: LifecycleOwner) {
+                    checkAndCancelPendingOperation()
+                }
+            })
+        }
+    }
+
+    /**
+     * Atomically clears the pending cancellation handler and invokes it.
+     * The double-checked pattern ensures only one caller (SDK callback vs. lifecycle event)
+     * wins the race (Requirement 11.3).
+     */
+    private fun checkAndCancelPendingOperation() {
+        val cancel = pendingOperationCancellation
+        if (cancel != null) {
+            synchronized(this) {
+                if (pendingOperationCancellation != null) {
+                    pendingOperationCancellation = null
+                    cancel()
+                }
+            }
+        }
+    }
+
     // Get or create Ethereum SDK instance
     // Important: DappMetadata.url must be a valid HTTP/HTTPS URL (not a deep link scheme)
     // The SDK automatically detects and uses the deep link from AndroidManifest.xml
@@ -112,6 +153,21 @@ class HybridNitroMetamask : HybridNitroMetamaskSpec() {
         }
     }
     
+    /**
+     * Check if MetaMask is installed on the device.
+     * Queries PackageManager for the io.metamask package.
+     * Returns true if found, false otherwise.
+     */
+    private fun isMetaMaskInstalled(): Boolean {
+        return try {
+            val context = MetamaskContextHolder.get()
+            context.packageManager.getPackageInfo("io.metamask", 0)
+            true
+        } catch (e: PackageManager.NameNotFoundException) {
+            false
+        }
+    }
+
     /**
      * Get the deep link scheme - uses configured value first, then attempts auto-detection.
      * Directly reads intent filters from PackageManager to find the scheme with host="mmsdk"
@@ -248,15 +304,29 @@ class HybridNitroMetamask : HybridNitroMetamaskSpec() {
         // Use Promise.async with coroutines for best practice in Nitro modules
         // Reference: https://nitro.margelo.com/docs/types/promises
         return Promise.async {
+            if (!isMetaMaskInstalled()) {
+                throw Exception("[2] MetaMask is not installed")
+            }
             // Convert callback-based connect() to suspend function using suspendCancellableCoroutine
             // This handles cancellation properly when JS GC disposes the promise
+            var localContinuation: CancellableContinuation<Result>? = null
+            pendingOperationCancellation = {
+                localContinuation?.let { cont ->
+                    if (cont.isActive) cont.resumeWithException(
+                        Exception("MetaMask operation cancelled: user returned to app without completing the request")
+                    )
+                }
+            }
             val result = suspendCancellableCoroutine<Result> { continuation ->
+                localContinuation = continuation
                 ethereum.connect { callbackResult ->
+                    pendingOperationCancellation = null
                     if (continuation.isActive) {
                         continuation.resume(callbackResult)
                     }
                 }
             }
+            pendingOperationCancellation = null
             
             when (result) {
                 is Result.Success.Item -> {
@@ -304,6 +374,9 @@ class HybridNitroMetamask : HybridNitroMetamaskSpec() {
         // Use Promise.async with coroutines for best practice in Nitro modules
         // Reference: https://nitro.margelo.com/docs/types/promises
         return Promise.async {
+            if (!isMetaMaskInstalled()) {
+                throw Exception("[2] MetaMask is not installed")
+            }
             // Verify connection state before attempting to sign
             // MetaMask SDK requires an active connection to sign messages
             val address = ethereum.selectedAddress
@@ -322,13 +395,24 @@ class HybridNitroMetamask : HybridNitroMetamaskSpec() {
             
             // Convert callback-based sendRequest() to suspend function
             // The SDK will automatically handle deep link return to the app
+            var localContinuation: CancellableContinuation<Result>? = null
+            pendingOperationCancellation = {
+                localContinuation?.let { cont ->
+                    if (cont.isActive) cont.resumeWithException(
+                        Exception("MetaMask operation cancelled: user returned to app without completing the request")
+                    )
+                }
+            }
             val result = suspendCancellableCoroutine<Result> { continuation ->
+                localContinuation = continuation
                 ethereum.sendRequest(request) { callbackResult ->
+                    pendingOperationCancellation = null
                     if (continuation.isActive) {
                         continuation.resume(callbackResult)
                     }
                 }
             }
+            pendingOperationCancellation = null
             
             when (result) {
                 is Result.Success.Item -> {
@@ -368,6 +452,9 @@ class HybridNitroMetamask : HybridNitroMetamaskSpec() {
         // The SDK's connectSign method handles connection and signing in one call
         return Promise.async {
             try {
+                if (!isMetaMaskInstalled()) {
+                    throw Exception("[2] MetaMask is not installed")
+                }
                 // Construct JSON message with only nonce and exp
                 // We don't include address or chainID - just encrypt nonce and exp
                 val message = org.json.JSONObject().apply {
@@ -380,9 +467,19 @@ class HybridNitroMetamask : HybridNitroMetamaskSpec() {
                 // Use the SDK's connectSign method - it will connect if needed and sign the message
                 // This is the recommended approach per MetaMask Android SDK documentation
                 // The SDK will handle bringing the app back to foreground via deep linking
+                var localContinuation: CancellableContinuation<Result>? = null
+                pendingOperationCancellation = {
+                    localContinuation?.let { cont ->
+                        if (cont.isActive) cont.resumeWithException(
+                            Exception("MetaMask operation cancelled: user returned to app without completing the request")
+                        )
+                    }
+                }
                 val result = suspendCancellableCoroutine<Result> { continuation ->
+                    localContinuation = continuation
                     Log.d("NitroMetamask", "connectSign: Calling ethereum.connectSign with message")
                     ethereum.connectSign(message) { callbackResult ->
+                        pendingOperationCancellation = null
                         Log.d("NitroMetamask", "connectSign: Received callback result: ${callbackResult.javaClass.simpleName}")
                         if (continuation.isActive) {
                             continuation.resume(callbackResult)
@@ -391,6 +488,7 @@ class HybridNitroMetamask : HybridNitroMetamaskSpec() {
                         }
                     }
                 }
+                pendingOperationCancellation = null
                 
                 Log.d("NitroMetamask", "connectSign: Processing result")
                 when (result) {
@@ -548,7 +646,7 @@ class HybridNitroMetamask : HybridNitroMetamaskSpec() {
             val state = ethereum.ethereumState.value
             val address = state?.selectedAddress?.takeIf { it.isNotEmpty() } ?: ethereum.selectedAddress
             Log.d("NitroMetamask", "getAddress: ethereumState.value?.selectedAddress = ${state?.selectedAddress}, ethereum.selectedAddress = ${ethereum.selectedAddress}, final = $address")
-            if (address == null || address.isEmpty()) {
+            if (address.isEmpty()) {
                 Log.w("NitroMetamask", "getAddress: Address is null or empty")
                 // Use NullType.NULL singleton as per Nitro documentation: https://nitro.margelo.com/docs/types/nulls
                 Variant_NullType_String.First(NullType.NULL)
@@ -566,7 +664,7 @@ class HybridNitroMetamask : HybridNitroMetamaskSpec() {
             val state = ethereum.ethereumState.value
             val chainIdString = state?.chainId?.takeIf { it.isNotEmpty() } ?: ethereum.chainId
             Log.d("NitroMetamask", "getChainId: ethereumState.value?.chainId = ${state?.chainId}, ethereum.chainId = ${ethereum.chainId}, final = $chainIdString")
-            if (chainIdString == null || chainIdString.isEmpty()) {
+            if (chainIdString.isEmpty()) {
                 Log.w("NitroMetamask", "getChainId: ChainId is null or empty")
                 // Use NullType.NULL singleton as per Nitro documentation: https://nitro.margelo.com/docs/types/nulls
                 Variant_NullType_Long.First(NullType.NULL)

package/android/src/main/java/io/metamask/androidsdk/AnyRequest.kt

@@ -0,0 +1,8 @@
+package io.metamask.androidsdk
+
+data class AnyRequest(
+    override var id: String = TimeStampGenerator.timestamp(),
+    override val method: String,
+    override val params: Any?
+) : RpcRequest()
+

package/android/src/main/java/io/metamask/androidsdk/ClientMessageServiceCallback.kt

@@ -0,0 +1,12 @@
+package io.metamask.androidsdk
+
+import android.os.Bundle
+import io.metamask.nativesdk.IMessegeServiceCallback
+
+open class ClientMessageServiceCallback(
+    var onMessage: ((Bundle) -> Unit)? = null
+) : IMessegeServiceCallback.Stub() {
+    override fun onMessageReceived(bundle: Bundle) {
+        onMessage?.invoke(bundle)
+    }
+}

package/android/src/main/java/io/metamask/androidsdk/ClientServiceConnection.kt

@@ -0,0 +1,42 @@
+package io.metamask.androidsdk
+
+import android.content.ComponentName
+import android.content.ServiceConnection
+import android.os.Bundle
+import android.os.IBinder
+import io.metamask.nativesdk.IMessegeService
+import io.metamask.nativesdk.IMessegeServiceCallback
+
+open class ClientServiceConnection(
+    var onConnected: (() -> Unit)? = null,
+    var onDisconnected: ((ComponentName?) -> Unit)? = null,
+    var onBindingDied: ((ComponentName?) -> Unit)? = null,
+    var onNullBinding: ((ComponentName?) -> Unit)? = null
+) : ServiceConnection {
+    private var messageService: IMessegeService? = null
+
+    override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
+        messageService = IMessegeService.Stub.asInterface(service)
+        onConnected?.invoke()
+    }
+
+    override fun onServiceDisconnected(name: ComponentName?) {
+        onDisconnected?.invoke(name)
+    }
+
+    override fun onBindingDied(name: ComponentName?) {
+        onBindingDied?.invoke(name)
+    }
+
+    override fun onNullBinding(name: ComponentName?) {
+        onNullBinding?.invoke(name)
+    }
+
+    open fun registerCallback(callback: IMessegeServiceCallback) {
+        messageService?.registerCallback(callback)
+    }
+
+    open fun sendMessage(bundle: Bundle) {
+        messageService?.sendMessage(bundle)
+    }
+}