@solana-mobile/mobile-wallet-adapter-walletlib 1.0.0

package/android/src/main/java/com/solanamobile/mobilewalletadapterwalletlib/reactnative/JsonSerializationUtils.kt

@@ -0,0 +1,83 @@
+package com.solanamobile.mobilewalletadapterwalletlib.reactnative
+
+import com.solanamobile.mobilewalletadapterwalletlib.reactnative.model.AuthorizeDappResponse
+import com.solanamobile.mobilewalletadapterwalletlib.reactnative.model.MobileWalletAdapterFailureResponse
+import com.solanamobile.mobilewalletadapterwalletlib.reactnative.model.MobileWalletAdapterRequest
+import com.solanamobile.mobilewalletadapterwalletlib.reactnative.model.MobileWalletAdapterResponse
+import com.solanamobile.mobilewalletadapterwalletlib.reactnative.model.SignedAndSentTransactions
+import com.solanamobile.mobilewalletadapterwalletlib.reactnative.model.SignedPayloads
+import kotlinx.serialization.DeserializationStrategy
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.builtins.ByteArraySerializer
+import kotlinx.serialization.builtins.ListSerializer
+import kotlinx.serialization.builtins.MapSerializer
+import kotlinx.serialization.builtins.serializer
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.json.JsonContentPolymorphicSerializer
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonTransformingSerializer
+
+internal open class TypeTransformingSerializer<T: Any>(serializer: KSerializer<T>) : JsonTransformingSerializer<T>(serializer) {
+    override fun transformSerialize(element: JsonElement): JsonElement =
+        if ((element as? JsonObject)?.containsKey("type") == true)
+            JsonObject(element.toMutableMap().apply {
+                this["__type"] = this.remove("type")!!
+            })
+        else element
+
+    override fun transformDeserialize(element: JsonElement): JsonElement =
+        if ((element as? JsonObject)?.containsKey("__type") == true)
+            JsonObject(element.toMutableMap().apply {
+                this["type"] = this.remove("__type")!!
+            })
+        else element
+}
+
+internal object FailReasonTransformingSerializer 
+    : JsonTransformingSerializer<MobileWalletAdapterFailureResponse>(MobileWalletAdapterFailureResponse.serializer()) {
+    override fun transformDeserialize(element: JsonElement): JsonElement =
+        if ((element as? JsonObject)?.containsKey("failReason") == true)
+            JsonObject(element.toMutableMap().apply {
+                this["type"] = this.remove("failReason")!!
+            })
+        else element
+}
+
+internal object MobileWalletAdapterResponseSerializer : JsonContentPolymorphicSerializer<MobileWalletAdapterResponse>(MobileWalletAdapterResponse::class) {
+    override fun selectDeserializer(element: JsonElement): DeserializationStrategy<out MobileWalletAdapterResponse> =
+        if ((element as? JsonObject)?.containsKey("failReason") == true) FailReasonTransformingSerializer
+        else if ((element as? JsonObject)?.containsKey("publicKey") == true) AuthorizeDappResponse.serializer()
+        else if ((element as? JsonObject)?.containsKey("signedPayloads") == true) SignedPayloads.serializer()
+        else if ((element as? JsonObject)?.containsKey("signedTransactions") == true) SignedAndSentTransactions.serializer() 
+        else MobileWalletAdapterResponse.serializer()
+}
+
+internal object MobileWalletAdapterRequestSerializer : TypeTransformingSerializer<MobileWalletAdapterRequest>(MobileWalletAdapterRequest.serializer())
+
+internal object ByteArrayAsMapSerializer : KSerializer<ByteArray> {
+    override val descriptor: SerialDescriptor = ByteArraySerializer().descriptor
+
+    override fun deserialize(decoder: Decoder): ByteArray =
+        try {
+            decoder.decodeSerializableValue(MapSerializer(String.serializer(), Int.serializer())).values.map { it.toByte() }.toByteArray()
+        } catch (e: Exception) {
+            decoder.decodeSerializableValue(ByteArraySerializer())
+        }
+
+    override fun serialize(encoder: Encoder, value: ByteArray) {
+        TODO("Not yet implemented")
+    }
+}
+
+object ByteArrayCollectionAsMapCollectionSerializer : KSerializer<List<ByteArray>> {
+    override val descriptor: SerialDescriptor = ListSerializer(ByteArraySerializer()).descriptor
+
+    override fun deserialize(decoder: Decoder): List<ByteArray> =
+        decoder.decodeSerializableValue(ListSerializer(ByteArrayAsMapSerializer))
+
+    override fun serialize(encoder: Encoder, value: List<ByteArray>) =
+        encoder.encodeSerializableValue(ListSerializer(ByteArrayAsMapSerializer), value)
+}

package/android/src/main/java/com/solanamobile/mobilewalletadapterwalletlib/reactnative/MobileWalletAdapterBottomSheetActivity.kt

@@ -0,0 +1,55 @@
+package com.solanamobile.mobilewalletadapterwalletlib.reactnative
+
+import android.os.Bundle
+import android.view.Gravity
+import android.view.WindowManager
+
+import com.facebook.react.ReactActivity
+import com.facebook.react.ReactActivityDelegate
+import com.facebook.react.ReactRootView
+
+class MobileWalletAdapterBottomSheetActivity : ReactActivity() {
+
+    /**
+     * Returns the name of the main component registered from JavaScript. This is used to schedule
+     * rendering of the component.
+     */
+    override protected  fun getMainComponentName() = "MobileWalletAdapterEntrypoint"
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+
+        val windowLayoutParams = window.attributes
+
+        windowLayoutParams.gravity = Gravity.BOTTOM
+        windowLayoutParams.flags =
+            windowLayoutParams.flags and WindowManager.LayoutParams.FLAG_DIM_BEHIND
+
+        window.attributes = windowLayoutParams
+        super.onCreate(null)
+    }
+
+    /**
+     * Returns the instance of the [ReactActivityDelegate]. There the RootView is created and
+     * you can specify the renderer you wish to use - the new renderer (Fabric) or the old renderer
+     * (Paper).
+     */
+    override protected fun createReactActivityDelegate(): ReactActivityDelegate {
+        return MainActivityDelegate(this, mainComponentName)
+    }
+
+    class MainActivityDelegate(val activity: ReactActivity?, mainComponentName: String?) :
+        ReactActivityDelegate(activity, mainComponentName) {
+
+        override protected fun createRootView(): ReactRootView {
+            val reactRootView = ReactRootView(getContext())
+            // If you opted-in for the New Architecture, we enable the Fabric Renderer.
+            reactRootView.setIsFabric(false)
+
+            return reactRootView
+        }
+
+        // If you opted-in for the New Architecture, we enable Concurrent Root (i.e. React 18).
+        // More on this on https://reactjs.org/blog/2022/03/29/react-v18.html
+        override protected fun isConcurrentRootEnabled() = false
+    }
+}

package/android/src/main/java/com/solanamobile/mobilewalletadapterwalletlib/reactnative/MobileWalletAdapterWalletLibReactNativePackage.kt

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

package/android/src/main/java/com/solanamobile/mobilewalletadapterwalletlib/reactnative/SolanaMobileWalletAdapterWalletLibModule.kt

@@ -0,0 +1,401 @@
+package com.solanamobile.mobilewalletadapterwalletlib.reactnative
+
+import android.net.Uri
+import android.util.Log
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.solana.mobilewalletadapter.common.util.NotifyingCompletableFuture
+import com.solana.mobilewalletadapter.walletlib.association.AssociationUri
+import com.solana.mobilewalletadapter.walletlib.association.LocalAssociationUri
+import com.solana.mobilewalletadapter.walletlib.authorization.AuthIssuerConfig
+import com.solana.mobilewalletadapter.walletlib.protocol.MobileWalletAdapterConfig
+import com.solana.mobilewalletadapter.walletlib.scenario.*
+import com.solana.mobilewalletadapter.common.ProtocolContract
+import com.solanamobile.mobilewalletadapterwalletlib.reactnative.BuildConfig
+import com.solanamobile.mobilewalletadapterwalletlib.reactnative.model.*
+import kotlinx.coroutines.*
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.jsonObject
+import java.util.UUID
+
+class SolanaMobileWalletAdapterWalletLibModule(val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext), CoroutineScope {
+
+    private val json = Json { ignoreUnknownKeys = true }
+
+    // Sets the name of the module in React, accessible at ReactNative.NativeModules.SolanaMobileWalletAdapterWalletLib
+    override fun getName() = "SolanaMobileWalletAdapterWalletLib"
+    
+    override val coroutineContext =
+        Dispatchers.IO + CoroutineName("SolanaMobileWalletAdapterWalletLibModuleScope") + SupervisorJob()
+
+    // Session events that notify about the lifecycle of the Scenario session. We are choosing
+    // to go with the naming convention Session rather than Scenario for readability.
+    sealed interface MobileWalletAdapterSessionEvent {
+        val type: String
+        object None : MobileWalletAdapterSessionEvent {
+            override val type: String = ""
+        }
+        object SessionTerminated : MobileWalletAdapterSessionEvent {
+            override val type: String = "SESSION_TERMINATED"
+        }
+        object ScenarioReady : MobileWalletAdapterSessionEvent {
+            override val type: String = "SESSION_READY"
+        }
+        object ScenarioServingClients : MobileWalletAdapterSessionEvent {
+            override val type: String = "SESSION_SERVING_CLIENTS"
+        }
+        object ScenarioServingComplete : MobileWalletAdapterSessionEvent {
+            override val type: String = "SESSION_SERVING_COMPLETE"
+        }
+        object ScenarioComplete : MobileWalletAdapterSessionEvent {
+            override val type: String = "SESSION_COMPLETE"
+        }
+        class ScenarioError(val message: String? = null) : MobileWalletAdapterSessionEvent {
+            override val type: String = "SESSION_ERROR"
+        }
+        object ScenarioTeardownComplete : MobileWalletAdapterSessionEvent {
+            override val type: String = "SESSION_TEARDOWN_COMPLETE"
+        }
+        object LowPowerNoConnection : MobileWalletAdapterSessionEvent {
+            override val type: String = "LOW_POWER_NO_CONNECTION"
+        }
+    }
+
+    // Service requests that come from the dApp for Authorization, Signing, Sending, hence "RemoteRequest".
+    sealed class MobileWalletAdapterRemoteRequest(open val request: ScenarioRequest, 
+                                                  val id: String = UUID.randomUUID().toString()) {
+        data class AuthorizeDapp(override val request: AuthorizeRequest) : MobileWalletAdapterRemoteRequest(request)
+        data class ReauthorizeDapp(override val request: ReauthorizeRequest) : MobileWalletAdapterRemoteRequest(request)
+
+        sealed class SignPayloads(override val request: SignPayloadsRequest) : MobileWalletAdapterRemoteRequest(request)
+        data class SignTransactions(override val request: SignTransactionsRequest) : SignPayloads(request)
+        data class SignMessages(override val request: SignMessagesRequest) : SignPayloads(request)
+        data class SignAndSendTransactions(
+            override val request: SignAndSendTransactionsRequest,
+            val endpointUri: Uri,
+        ) : MobileWalletAdapterRemoteRequest(request)
+    }
+
+    // currently we only allow a single scenario to exist at a time
+    private var scenarioId: String? = null
+    private var scenarioUri: Uri? = null
+    private var scenario: Scenario? = null
+        set(value) {
+            value?.let { scenarioId = UUID.randomUUID().toString() } ?: run {
+                scenarioId = null
+                scenario?.close()
+            }
+            pendingRequests.clear()
+            field = value
+        }
+
+    // very basic/naive implememtion of request cache. 
+    // we could replace this with an abstraction that has expiration, persistance, etc. 
+    private val pendingRequests = mutableMapOf<String, MobileWalletAdapterRemoteRequest>()
+
+    private fun clusterToRpcUri(cluster: String?): Uri {
+        return when (cluster) {
+            ProtocolContract.CLUSTER_MAINNET_BETA ->
+                Uri.parse("https://api.mainnet-beta.solana.com")
+            ProtocolContract.CLUSTER_DEVNET ->
+                Uri.parse("https://api.devnet.solana.com")
+            else ->
+                Uri.parse("https://api.testnet.solana.com")
+        }
+    }
+
+    @ReactMethod
+    fun createScenario(
+        walletName: String,
+        uriStr: String,
+        config: String,
+    ) = launch {
+        val uri = Uri.parse(uriStr)
+
+        // TODO: this is dirty, need some stateful object/data to know what state we are in.
+        //  also, should we suport multiple simulatneous scenario?
+        if (uri == scenarioUri && scenario != null) {
+            Log.w(TAG, "Session already created for uri: $uri")
+            return@launch
+        }
+
+        val associationUri = AssociationUri.parse(uri)
+        if (associationUri == null) {
+            Log.e(TAG, "Unsupported association URI: $uri")
+            return@launch
+        } else if (associationUri !is LocalAssociationUri) {
+            Log.e(TAG, "Current implementation of fakewallet does not support remote clients")
+            return@launch
+        }
+
+        scenarioUri = uri
+
+        val kotlinConfig = json.decodeFromString(MobileWalletAdapterConfigSerializer, config)
+
+        // created a scenario, told it to start (kicks off some threads in the background)
+        // we've kept a reference to it in the global state of this module (scenario)
+        // this won't be garbage collected and will just run, sit & wait for an incoming connection
+        scenario = associationUri.createScenario(
+            reactContext,
+            kotlinConfig,
+            AuthIssuerConfig(walletName),
+            MobileWalletAdapterScenarioCallbacks()
+        ).also { it.start() }
+
+        Log.d(TAG, "scenario created: $walletName")
+    }
+
+    /* Generic Request functions */
+    @ReactMethod
+    fun cancelRequest(sessionId: String, requestId: String) {
+        Log.d(TAG, "Cancelled request $requestId");
+        (pendingRequests.remove(requestId) as? ScenarioRequest)?.let { scenarioRequest ->
+            scenarioRequest.cancel();
+        }
+    }
+
+    // Apparently we cant have overlaod methods like this becuase React is completly idiotic
+    // @ReactMethod
+    // fun resolve(request: ReadableMap, response: ReadableMap) {
+    //     resolve(request.toJson().toString(), response.toJson().toString())
+    // }
+
+    @ReactMethod
+    fun resolve(requestJson: String, responseJson: String) = launch {
+        val completedRequest = json.decodeFromString(MobileWalletAdapterRequestSerializer, requestJson)
+        val response = json.decodeFromString(MobileWalletAdapterResponseSerializer, responseJson)
+        val pendingRequest = pendingRequests[completedRequest.requestId]
+
+        if (completedRequest.sessionId != scenarioId) {
+            sendSessionEventToReact(MobileWalletAdapterSessionEvent.ScenarioError(
+                "Invalid session (${completedRequest.sessionId}). This session does not exist/is no longer active."
+            ))
+            return@launch
+        }
+
+        fun completeWithInvalidResponse() {
+            pendingRequest?.request?.completeWithInternalError(Exception("Invalid Response For Request: response = $responseJson"))
+        }
+
+        when (completedRequest) {
+            is AuthorizeDapp -> when (response) {
+                is MobileWalletAdapterFailureResponse -> {
+                    when (response) {
+                        is UserDeclinedResponse ->
+                            (pendingRequest as? MobileWalletAdapterRemoteRequest.AuthorizeDapp)?.request?.completeWithDecline()
+                        else -> completeWithInvalidResponse()
+                    }
+                }
+                is AuthorizeDappResponse ->
+                    (pendingRequest as? MobileWalletAdapterRemoteRequest.AuthorizeDapp)
+                        ?.request?.completeWithAuthorize(
+                            response.publicKey,
+                            response.accountLabel,
+                            null, //Uri.parse(response.walletUriBase),
+                            null //response.authorizationScope
+                        )
+                else -> completeWithInvalidResponse()
+            }
+            is ReauthorizeDapp -> when (response) {
+                is MobileWalletAdapterFailureResponse -> {
+                    when (response) {
+                        is UserDeclinedResponse ->
+                            (pendingRequest as? MobileWalletAdapterRemoteRequest.ReauthorizeDapp)?.request?.completeWithDecline()
+                        else -> completeWithInvalidResponse()
+                    }
+                }
+                is AuthorizeDappResponse ->
+                    (pendingRequest as? MobileWalletAdapterRemoteRequest.ReauthorizeDapp)?.request?.completeWithReauthorize()
+                else -> completeWithInvalidResponse()
+            }
+            is SignAndSendTransactions -> when (response) {
+                is MobileWalletAdapterFailureResponse -> {
+                    when (response) {
+                        is UserDeclinedResponse  ->
+                            (pendingRequest as? MobileWalletAdapterRemoteRequest.SignAndSendTransactions)?.request?.completeWithDecline()
+                        is TooManyPayloadsResponse ->
+                            (pendingRequest as? MobileWalletAdapterRemoteRequest.SignAndSendTransactions)?.request?.completeWithTooManyPayloads()
+                        is AuthorizationNotValidResponse ->
+                            (pendingRequest as? MobileWalletAdapterRemoteRequest.SignAndSendTransactions)?.request?.completeWithAuthorizationNotValid()
+                        is InvalidSignaturesResponse ->
+                            (pendingRequest as? MobileWalletAdapterRemoteRequest.SignAndSendTransactions)?.request?.completeWithInvalidSignatures(response.valid)
+                    }
+                }
+                is SignedAndSentTransactions ->
+                    (pendingRequest as? MobileWalletAdapterRemoteRequest.SignAndSendTransactions)?.request?.completeWithSignatures(response.signedTransactions.toTypedArray())
+                else -> completeWithInvalidResponse()
+            }
+            is SignPayloads -> when (response) {
+                is MobileWalletAdapterFailureResponse -> {
+                    when (response) {
+                        is UserDeclinedResponse  ->
+                            (pendingRequest as? MobileWalletAdapterRemoteRequest.SignPayloads)?.request?.completeWithDecline()
+                        is TooManyPayloadsResponse ->
+                            (pendingRequest as? MobileWalletAdapterRemoteRequest.SignPayloads)?.request?.completeWithTooManyPayloads()
+                        is AuthorizationNotValidResponse ->
+                            (pendingRequest as? MobileWalletAdapterRemoteRequest.SignPayloads)?.request?.completeWithAuthorizationNotValid()
+                        is InvalidSignaturesResponse ->
+                            (pendingRequest as? MobileWalletAdapterRemoteRequest.SignPayloads)?.request?.completeWithInvalidPayloads(response.valid)
+                    }
+                }
+                is SignedPayloads ->
+                    (pendingRequest as? MobileWalletAdapterRemoteRequest.SignPayloads)?.request?.completeWithSignedPayloads(response.signedPayloads.toTypedArray())
+                else -> completeWithInvalidResponse()
+            }
+        }
+    }
+
+    private fun checkSessionId(sessionId: String, doIfValid: (() -> Unit)) = 
+        if (sessionId == scenarioId) doIfValid() 
+        else sendSessionEventToReact(MobileWalletAdapterSessionEvent.ScenarioError(
+            "Invalid session ($sessionId). This session does not exist/is no longer active."
+        ))
+
+    private fun sendSessionEventToReact(sessionEvent: MobileWalletAdapterSessionEvent) {
+        val eventInfo = when(sessionEvent) {
+            is MobileWalletAdapterSessionEvent.None -> null
+            is MobileWalletAdapterSessionEvent.ScenarioError -> Arguments.createMap().apply {
+                putString("__type", sessionEvent.type)
+                putString("error", sessionEvent.message)
+            }
+            else -> Arguments.createMap().apply {
+                putString("__type", sessionEvent.type)
+            }
+        }
+
+        eventInfo?.putString("sessionId", scenarioId)
+
+        eventInfo?.let { sendEvent(reactContext,
+            Companion.MOBILE_WALLET_ADAPTER_SERVICE_REQUEST_BRIDGE_NAME, it) }
+    }
+
+    private fun sendWalletServiceRequestToReact(request: MobileWalletAdapterRemoteRequest) {
+        val surrogate = when(request) {
+            is MobileWalletAdapterRemoteRequest.AuthorizeDapp -> AuthorizeDapp(
+                scenarioId!!, request.request.cluster, request.request.identityName,
+                request.request.identityUri.toString(), request.request.iconRelativeUri.toString()
+            )
+            is MobileWalletAdapterRemoteRequest.ReauthorizeDapp -> ReauthorizeDapp(
+                scenarioId!!, request.request.cluster, request.request.identityName,
+                request.request.identityUri.toString(), request.request.iconRelativeUri.toString(),
+                request.request.authorizationScope
+            )
+            is MobileWalletAdapterRemoteRequest.SignMessages -> SignMessages(
+                scenarioId!!, request.request.cluster, request.request.identityName,
+                request.request.identityUri.toString(), request.request.iconRelativeUri.toString(),
+                request.request.authorizationScope, request.request.payloads.toList()
+            )
+            is MobileWalletAdapterRemoteRequest.SignTransactions -> SignTransactions(
+                scenarioId!!, request.request.cluster, request.request.identityName,
+                request.request.identityUri.toString(), request.request.iconRelativeUri.toString(),
+                request.request.authorizationScope, request.request.payloads.toList()
+            )
+            is MobileWalletAdapterRemoteRequest.SignAndSendTransactions -> SignAndSendTransactions(
+                scenarioId!!, request.request.cluster, request.request.identityName,
+                request.request.identityUri.toString(), request.request.iconRelativeUri.toString(),
+                request.request.authorizationScope, request.request.payloads.toList()
+            )
+        }
+
+        // this is dirty, the requestId needs to line up so have to manually overwrite here
+        // should we change javascript side to accept json?
+        val eventInfo = 
+            JsonObject(json.encodeToJsonElement(MobileWalletAdapterRequestSerializer, surrogate)
+                .jsonObject.toMutableMap().apply { 
+                    put("requestId", JsonPrimitive(request.id))
+                }).toReadableMap()
+
+        sendEvent(reactContext, Companion.MOBILE_WALLET_ADAPTER_SERVICE_REQUEST_BRIDGE_NAME, eventInfo)
+    }
+
+    private fun sendEvent(reactContext: ReactContext, eventName: String, params: ReadableMap? = null) {
+        reactContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(eventName, params)
+    }
+
+    private inner class MobileWalletAdapterScenarioCallbacks : LocalScenario.Callbacks {
+        /* Session Events */
+        override fun onScenarioReady() {
+            sendSessionEventToReact(MobileWalletAdapterSessionEvent.ScenarioReady)
+        }
+
+        override fun onScenarioServingClients() {
+            sendSessionEventToReact(MobileWalletAdapterSessionEvent.ScenarioServingClients)
+        }
+
+        override fun onScenarioServingComplete() {
+            launch(Dispatchers.Main) {
+                scenario = null
+                sendSessionEventToReact(MobileWalletAdapterSessionEvent.ScenarioServingComplete)
+            }
+        }
+
+        override fun onScenarioComplete() {
+            sendSessionEventToReact(MobileWalletAdapterSessionEvent.ScenarioComplete)
+        }
+
+        override fun onScenarioError() {
+            sendSessionEventToReact(MobileWalletAdapterSessionEvent.ScenarioError())
+        }
+
+        override fun onScenarioTeardownComplete() {
+            sendSessionEventToReact(MobileWalletAdapterSessionEvent.ScenarioTeardownComplete)
+            sendSessionEventToReact(MobileWalletAdapterSessionEvent.SessionTerminated)
+        }
+
+        override fun onLowPowerAndNoConnection() {
+            sendSessionEventToReact(MobileWalletAdapterSessionEvent.LowPowerNoConnection)
+        }
+
+        /* Remote Requests */
+        override fun onAuthorizeRequest(request: AuthorizeRequest) {
+            val request = MobileWalletAdapterRemoteRequest.AuthorizeDapp(request)
+            pendingRequests.put(request.id, request)
+            sendWalletServiceRequestToReact(request)
+        }
+
+        override fun onReauthorizeRequest(request: ReauthorizeRequest) {
+            Log.i(TAG, "Reauthorization request: auto completing, DO NOT DO THIS IN PRODUCTION")
+            // TODO: Implement client trust use case
+            request.completeWithReauthorize()
+        }
+
+        override fun onSignTransactionsRequest(request: SignTransactionsRequest) {
+            val request = MobileWalletAdapterRemoteRequest.SignTransactions(request)
+            pendingRequests.put(request.id, request)
+            sendWalletServiceRequestToReact(request)
+        }
+
+        override fun onSignMessagesRequest(request: SignMessagesRequest) {
+            val request = MobileWalletAdapterRemoteRequest.SignMessages(request)
+            pendingRequests.put(request.id, request)
+            sendWalletServiceRequestToReact(request)
+        }
+
+        override fun onSignAndSendTransactionsRequest(request: SignAndSendTransactionsRequest) {
+            val endpointUri = clusterToRpcUri(request.cluster)
+            val request = MobileWalletAdapterRemoteRequest.SignAndSendTransactions(request, endpointUri)
+            pendingRequests.put(request.id, request)
+            sendWalletServiceRequestToReact(request)
+        }
+
+        private fun verifyPrivilegedMethodSource(request: VerifiableIdentityRequest): Boolean {
+            // TODO: Implement client trust use case
+            return true
+        }
+
+        override fun onDeauthorizedEvent(event: DeauthorizedEvent) {
+            event.complete()
+        }
+    }
+
+    companion object {
+        private val TAG = SolanaMobileWalletAdapterWalletLibModule::class.simpleName
+        const val MOBILE_WALLET_ADAPTER_SERVICE_REQUEST_BRIDGE_NAME = "MobileWalletAdapterServiceRequestBridge"
+        const val MOBILE_WALLET_ADAPTER_SESSION_EVENT_BRIDGE_NAME = "MobileWalletAdapterSessionEventBridge"
+    }
+}

package/android/src/main/java/com/solanamobile/mobilewalletadapterwalletlib/reactnative/model/MobileWalletAdapterConfig.kt

@@ -0,0 +1,60 @@
+package com.solanamobile.mobilewalletadapterwalletlib.reactnative.model
+
+import com.solana.mobilewalletadapter.walletlib.protocol.MobileWalletAdapterConfig
+import kotlinx.serialization.DeserializationStrategy
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.builtins.ListSerializer
+import kotlinx.serialization.builtins.serializer
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.json.JsonContentPolymorphicSerializer
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonPrimitive
+
+@Serializable
+data class MobileWalletAdapterConfigSurrogate(
+    val supportsSignAndSendTransactions: Boolean,
+    val maxTransactionsPerSigningRequest: Int,
+    val maxMessagesPerSigningRequest: Int,
+    val supportedTransactionVersions: List<@Serializable(with = TransactionVersionSerializer::class) Any>,
+    val noConnectionWarningTimeoutMs: Long,
+)
+
+object TransactionVersionSerializer : JsonContentPolymorphicSerializer<Any>(Any::class) {
+    override fun selectDeserializer(element: JsonElement): DeserializationStrategy<out Any> =
+        if ((element as? JsonPrimitive)?.content?.toIntOrNull() != null) Int.serializer()
+        else if ((element as? JsonPrimitive)?.content == "legacy") String.serializer()
+        else throw IllegalArgumentException("supportedTransactionVersions must be either the string \"legacy\" or a non-negative integer")
+}
+
+object MobileWalletAdapterConfigSerializer : KSerializer<MobileWalletAdapterConfig> {
+    private val delegateSerializer = MobileWalletAdapterConfigSurrogate.serializer()
+    override val descriptor: SerialDescriptor = delegateSerializer.descriptor
+
+    override fun deserialize(decoder: Decoder): MobileWalletAdapterConfig {
+        val surrogate = decoder.decodeSerializableValue(delegateSerializer)
+        return MobileWalletAdapterConfig(
+            surrogate.supportsSignAndSendTransactions, 
+            surrogate.maxTransactionsPerSigningRequest,
+            surrogate.maxMessagesPerSigningRequest,
+            surrogate.supportedTransactionVersions.toTypedArray(),
+            surrogate.noConnectionWarningTimeoutMs
+        )
+    }
+
+    override fun serialize(encoder: Encoder, value: MobileWalletAdapterConfig) {
+        encoder.encodeSerializableValue(delegateSerializer, 
+            MobileWalletAdapterConfigSurrogate(
+                value.supportsSignAndSendTransactions,
+                value.maxTransactionsPerSigningRequest,
+                value.maxMessagesPerSigningRequest,
+                value.supportedTransactionVersions.toList(),
+                value.noConnectionWarningTimeoutMs
+            )
+        )
+    }
+}